@ggakila/agentx-framework 0.1.0

package/dist/integrations/GoogleWorkspaceTool.js

@@ -0,0 +1,765 @@
+"use strict";
+/**
+ * Google Workspace Integration Tools
+ * Provides integrations for Google Docs, Sheets, and Drive
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleDriveTool = exports.googleDriveToolSpec = exports.GoogleSheetsTool = exports.googleSheetsToolSpec = exports.GoogleDocsTool = exports.googleDocsToolSpec = void 0;
+/**
+ * Google Docs Tool Specification
+ */
+exports.googleDocsToolSpec = {
+    name: 'google-docs',
+    version: '1.0.0',
+    description: 'Create and manage Google Docs documents',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['create', 'get', 'update', 'append', 'delete'],
+                description: 'Google Docs action',
+            },
+            documentId: { type: 'string', description: 'Document ID' },
+            title: { type: 'string', description: 'Document title' },
+            content: { type: 'string', description: 'Document content' },
+            index: { type: 'number', description: 'Insert index position' },
+        },
+        required: ['action'],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: {
+            success: { type: 'boolean' },
+            documentId: { type: 'string' },
+            title: { type: 'string' },
+            content: { type: 'string' },
+        },
+    },
+};
+/**
+ * Google Docs Integration
+ */
+class GoogleDocsTool {
+    config;
+    logger;
+    documents = new Map();
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    async execute(input) {
+        try {
+            switch (input.action) {
+                case 'create':
+                    return this.createDocument(input.title, input.content);
+                case 'get':
+                    return this.getDocument(input.documentId);
+                case 'update':
+                    return this.updateDocument(input.documentId, input.content, input.index);
+                case 'append':
+                    return this.appendToDocument(input.documentId, input.content);
+                case 'delete':
+                    return this.deleteDocument(input.documentId);
+                default:
+                    return { success: false, error: `Unknown action: ${input.action}` };
+            }
+        }
+        catch (error) {
+            this.logger.error('Google Docs error', error);
+            return { success: false, error: error.message };
+        }
+    }
+    async createDocument(title, content) {
+        if (!title) {
+            return { success: false, error: 'Title is required' };
+        }
+        const documentId = `doc_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.documents.set(documentId, { title, content: content || '' });
+        this.logger.info('Google Doc created', { documentId, title });
+        return {
+            success: true,
+            data: {
+                documentId,
+                title,
+                revisionId: '1',
+                documentUrl: `https://docs.google.com/document/d/${documentId}/edit`,
+            },
+        };
+    }
+    async getDocument(documentId) {
+        if (!documentId) {
+            return { success: false, error: 'Document ID is required' };
+        }
+        const doc = this.documents.get(documentId);
+        if (!doc) {
+            return { success: false, error: 'Document not found' };
+        }
+        return {
+            success: true,
+            data: {
+                documentId,
+                title: doc.title,
+                content: doc.content,
+                revisionId: '1',
+            },
+        };
+    }
+    async updateDocument(documentId, content, index) {
+        if (!documentId || content === undefined) {
+            return { success: false, error: 'Document ID and content are required' };
+        }
+        const doc = this.documents.get(documentId);
+        if (!doc) {
+            return { success: false, error: 'Document not found' };
+        }
+        if (index !== undefined) {
+            // Insert at specific position
+            const before = doc.content.slice(0, index);
+            const after = doc.content.slice(index);
+            doc.content = before + content + after;
+        }
+        else {
+            doc.content = content;
+        }
+        this.logger.info('Google Doc updated', { documentId });
+        return {
+            success: true,
+            data: {
+                documentId,
+                title: doc.title,
+                revisionId: '2',
+            },
+        };
+    }
+    async appendToDocument(documentId, content) {
+        if (!documentId || !content) {
+            return { success: false, error: 'Document ID and content are required' };
+        }
+        const doc = this.documents.get(documentId);
+        if (!doc) {
+            return { success: false, error: 'Document not found' };
+        }
+        doc.content += content;
+        this.logger.info('Content appended to Google Doc', { documentId });
+        return {
+            success: true,
+            data: {
+                documentId,
+                title: doc.title,
+                revisionId: '2',
+            },
+        };
+    }
+    async deleteDocument(documentId) {
+        if (!documentId) {
+            return { success: false, error: 'Document ID is required' };
+        }
+        const deleted = this.documents.delete(documentId);
+        if (!deleted) {
+            return { success: false, error: 'Document not found' };
+        }
+        this.logger.info('Google Doc deleted', { documentId });
+        return {
+            success: true,
+            data: { documentId, deleted: true },
+        };
+    }
+    getDocuments() {
+        return new Map(this.documents);
+    }
+    clearDocuments() {
+        this.documents.clear();
+    }
+}
+exports.GoogleDocsTool = GoogleDocsTool;
+/**
+ * Google Sheets Tool Specification
+ */
+exports.googleSheetsToolSpec = {
+    name: 'google-sheets',
+    version: '1.0.0',
+    description: 'Create and manage Google Sheets spreadsheets',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['create', 'get', 'read', 'write', 'append', 'clear', 'delete'],
+                description: 'Google Sheets action',
+            },
+            spreadsheetId: { type: 'string', description: 'Spreadsheet ID' },
+            title: { type: 'string', description: 'Spreadsheet title' },
+            sheetName: { type: 'string', description: 'Sheet name' },
+            range: { type: 'string', description: 'Cell range (e.g., A1:B10)' },
+            values: { type: 'array', description: '2D array of values' },
+        },
+        required: ['action'],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: {
+            success: { type: 'boolean' },
+            spreadsheetId: { type: 'string' },
+            values: { type: 'array' },
+            updatedCells: { type: 'number' },
+        },
+    },
+};
+/**
+ * Google Sheets Integration
+ */
+class GoogleSheetsTool {
+    config;
+    logger;
+    spreadsheets = new Map();
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    async execute(input) {
+        try {
+            switch (input.action) {
+                case 'create':
+                    return this.createSpreadsheet(input.title);
+                case 'get':
+                    return this.getSpreadsheet(input.spreadsheetId);
+                case 'read':
+                    return this.readRange(input.spreadsheetId, input.sheetName || 'Sheet1', input.range);
+                case 'write':
+                    return this.writeRange(input.spreadsheetId, input.sheetName || 'Sheet1', input.range, input.values);
+                case 'append':
+                    return this.appendRows(input.spreadsheetId, input.sheetName || 'Sheet1', input.values);
+                case 'clear':
+                    return this.clearRange(input.spreadsheetId, input.sheetName || 'Sheet1', input.range);
+                case 'delete':
+                    return this.deleteSpreadsheet(input.spreadsheetId);
+                default:
+                    return { success: false, error: `Unknown action: ${input.action}` };
+            }
+        }
+        catch (error) {
+            this.logger.error('Google Sheets error', error);
+            return { success: false, error: error.message };
+        }
+    }
+    async createSpreadsheet(title) {
+        if (!title) {
+            return { success: false, error: 'Title is required' };
+        }
+        const spreadsheetId = `sheet_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.spreadsheets.set(spreadsheetId, {
+            title,
+            sheets: new Map([['Sheet1', []]]),
+        });
+        this.logger.info('Google Sheet created', { spreadsheetId, title });
+        return {
+            success: true,
+            data: {
+                spreadsheetId,
+                title,
+                spreadsheetUrl: `https://docs.google.com/spreadsheets/d/${spreadsheetId}/edit`,
+                sheets: [{ sheetId: 0, title: 'Sheet1' }],
+            },
+        };
+    }
+    async getSpreadsheet(spreadsheetId) {
+        if (!spreadsheetId) {
+            return { success: false, error: 'Spreadsheet ID is required' };
+        }
+        const spreadsheet = this.spreadsheets.get(spreadsheetId);
+        if (!spreadsheet) {
+            return { success: false, error: 'Spreadsheet not found' };
+        }
+        const sheets = Array.from(spreadsheet.sheets.keys()).map((name, index) => ({
+            sheetId: index,
+            title: name,
+        }));
+        return {
+            success: true,
+            data: {
+                spreadsheetId,
+                title: spreadsheet.title,
+                sheets,
+            },
+        };
+    }
+    async readRange(spreadsheetId, sheetName, range) {
+        if (!spreadsheetId || !range) {
+            return { success: false, error: 'Spreadsheet ID and range are required' };
+        }
+        const spreadsheet = this.spreadsheets.get(spreadsheetId);
+        if (!spreadsheet) {
+            return { success: false, error: 'Spreadsheet not found' };
+        }
+        const sheet = spreadsheet.sheets.get(sheetName);
+        if (!sheet) {
+            return { success: false, error: `Sheet '${sheetName}' not found` };
+        }
+        const { startRow, startCol, endRow, endCol } = this.parseRange(range);
+        const values = [];
+        for (let row = startRow; row <= endRow && row < sheet.length; row++) {
+            const rowData = [];
+            for (let col = startCol; col <= endCol; col++) {
+                rowData.push(sheet[row]?.[col] ?? null);
+            }
+            values.push(rowData);
+        }
+        return {
+            success: true,
+            data: {
+                spreadsheetId,
+                range: `${sheetName}!${range}`,
+                values,
+            },
+        };
+    }
+    async writeRange(spreadsheetId, sheetName, range, values) {
+        if (!spreadsheetId || !range || !values) {
+            return { success: false, error: 'Spreadsheet ID, range, and values are required' };
+        }
+        const spreadsheet = this.spreadsheets.get(spreadsheetId);
+        if (!spreadsheet) {
+            return { success: false, error: 'Spreadsheet not found' };
+        }
+        let sheet = spreadsheet.sheets.get(sheetName);
+        if (!sheet) {
+            sheet = [];
+            spreadsheet.sheets.set(sheetName, sheet);
+        }
+        const { startRow, startCol } = this.parseRange(range);
+        let updatedCells = 0;
+        for (let i = 0; i < values.length; i++) {
+            const rowIndex = startRow + i;
+            if (!sheet[rowIndex]) {
+                sheet[rowIndex] = [];
+            }
+            for (let j = 0; j < values[i].length; j++) {
+                sheet[rowIndex][startCol + j] = values[i][j];
+                updatedCells++;
+            }
+        }
+        this.logger.info('Google Sheet range written', { spreadsheetId, range, updatedCells });
+        return {
+            success: true,
+            data: {
+                spreadsheetId,
+                updatedRange: `${sheetName}!${range}`,
+                updatedRows: values.length,
+                updatedColumns: values[0]?.length || 0,
+                updatedCells,
+            },
+        };
+    }
+    async appendRows(spreadsheetId, sheetName, values) {
+        if (!spreadsheetId || !values) {
+            return { success: false, error: 'Spreadsheet ID and values are required' };
+        }
+        const spreadsheet = this.spreadsheets.get(spreadsheetId);
+        if (!spreadsheet) {
+            return { success: false, error: 'Spreadsheet not found' };
+        }
+        let sheet = spreadsheet.sheets.get(sheetName);
+        if (!sheet) {
+            sheet = [];
+            spreadsheet.sheets.set(sheetName, sheet);
+        }
+        const startRow = sheet.length;
+        sheet.push(...values);
+        this.logger.info('Rows appended to Google Sheet', { spreadsheetId, rowsAdded: values.length });
+        return {
+            success: true,
+            data: {
+                spreadsheetId,
+                updatedRange: `${sheetName}!A${startRow + 1}`,
+                updatedRows: values.length,
+                updatedCells: values.reduce((sum, row) => sum + row.length, 0),
+            },
+        };
+    }
+    async clearRange(spreadsheetId, sheetName, range) {
+        if (!spreadsheetId || !range) {
+            return { success: false, error: 'Spreadsheet ID and range are required' };
+        }
+        const spreadsheet = this.spreadsheets.get(spreadsheetId);
+        if (!spreadsheet) {
+            return { success: false, error: 'Spreadsheet not found' };
+        }
+        const sheet = spreadsheet.sheets.get(sheetName);
+        if (!sheet) {
+            return { success: false, error: `Sheet '${sheetName}' not found` };
+        }
+        const { startRow, startCol, endRow, endCol } = this.parseRange(range);
+        let clearedCells = 0;
+        for (let row = startRow; row <= endRow && row < sheet.length; row++) {
+            for (let col = startCol; col <= endCol && col < (sheet[row]?.length || 0); col++) {
+                if (sheet[row]) {
+                    sheet[row][col] = null;
+                    clearedCells++;
+                }
+            }
+        }
+        this.logger.info('Google Sheet range cleared', { spreadsheetId, range, clearedCells });
+        return {
+            success: true,
+            data: {
+                spreadsheetId,
+                clearedRange: `${sheetName}!${range}`,
+                clearedCells,
+            },
+        };
+    }
+    async deleteSpreadsheet(spreadsheetId) {
+        if (!spreadsheetId) {
+            return { success: false, error: 'Spreadsheet ID is required' };
+        }
+        const deleted = this.spreadsheets.delete(spreadsheetId);
+        if (!deleted) {
+            return { success: false, error: 'Spreadsheet not found' };
+        }
+        this.logger.info('Google Sheet deleted', { spreadsheetId });
+        return {
+            success: true,
+            data: { spreadsheetId, deleted: true },
+        };
+    }
+    parseRange(range) {
+        // Parse range like "A1:B10" or "A1"
+        const match = range.match(/^([A-Z]+)(\d+)(?::([A-Z]+)(\d+))?$/i);
+        if (!match) {
+            return { startRow: 0, startCol: 0, endRow: 999, endCol: 25 };
+        }
+        const colToNum = (col) => {
+            let num = 0;
+            for (let i = 0; i < col.length; i++) {
+                num = num * 26 + (col.charCodeAt(i) - 64);
+            }
+            return num - 1;
+        };
+        const startCol = colToNum(match[1].toUpperCase());
+        const startRow = parseInt(match[2], 10) - 1;
+        const endCol = match[3] ? colToNum(match[3].toUpperCase()) : startCol;
+        const endRow = match[4] ? parseInt(match[4], 10) - 1 : startRow;
+        return { startRow, startCol, endRow, endCol };
+    }
+    getSpreadsheets() {
+        return new Map(this.spreadsheets);
+    }
+    clearSpreadsheets() {
+        this.spreadsheets.clear();
+    }
+}
+exports.GoogleSheetsTool = GoogleSheetsTool;
+/**
+ * Google Drive Tool Specification
+ */
+exports.googleDriveToolSpec = {
+    name: 'google-drive',
+    version: '1.0.0',
+    description: 'Manage files and folders in Google Drive',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['list', 'get', 'create', 'upload', 'download', 'delete', 'move', 'copy', 'share'],
+                description: 'Google Drive action',
+            },
+            fileId: { type: 'string', description: 'File ID' },
+            folderId: { type: 'string', description: 'Folder ID' },
+            name: { type: 'string', description: 'File or folder name' },
+            mimeType: { type: 'string', description: 'MIME type' },
+            content: { type: 'string', description: 'File content (base64 for binary)' },
+            query: { type: 'string', description: 'Search query' },
+            email: { type: 'string', description: 'Email for sharing' },
+            role: { type: 'string', enum: ['reader', 'writer', 'commenter'], description: 'Share role' },
+        },
+        required: ['action'],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: {
+            success: { type: 'boolean' },
+            fileId: { type: 'string' },
+            files: { type: 'array' },
+            content: { type: 'string' },
+        },
+    },
+};
+/**
+ * Google Drive Integration
+ */
+class GoogleDriveTool {
+    config;
+    logger;
+    files = new Map();
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+        // Create root folder
+        this.files.set('root', {
+            id: 'root',
+            name: 'My Drive',
+            mimeType: 'application/vnd.google-apps.folder',
+            createdTime: new Date(),
+            modifiedTime: new Date(),
+            permissions: [],
+        });
+    }
+    async execute(input) {
+        try {
+            switch (input.action) {
+                case 'list':
+                    return this.listFiles(input.folderId, input.query);
+                case 'get':
+                    return this.getFile(input.fileId);
+                case 'create':
+                    return this.createFolder(input.name, input.folderId);
+                case 'upload':
+                    return this.uploadFile(input.name, input.content, input.mimeType, input.folderId);
+                case 'download':
+                    return this.downloadFile(input.fileId);
+                case 'delete':
+                    return this.deleteFile(input.fileId);
+                case 'move':
+                    return this.moveFile(input.fileId, input.folderId);
+                case 'copy':
+                    return this.copyFile(input.fileId, input.name);
+                case 'share':
+                    return this.shareFile(input.fileId, input.email, input.role);
+                default:
+                    return { success: false, error: `Unknown action: ${input.action}` };
+            }
+        }
+        catch (error) {
+            this.logger.error('Google Drive error', error);
+            return { success: false, error: error.message };
+        }
+    }
+    async listFiles(folderId, query) {
+        const parentId = folderId || 'root';
+        let files = Array.from(this.files.values()).filter(f => f.id !== 'root' && (f.parentId === parentId || (!f.parentId && parentId === 'root')));
+        if (query) {
+            const lowerQuery = query.toLowerCase();
+            files = files.filter(f => f.name.toLowerCase().includes(lowerQuery));
+        }
+        return {
+            success: true,
+            data: {
+                files: files.map(f => ({
+                    id: f.id,
+                    name: f.name,
+                    mimeType: f.mimeType,
+                    createdTime: f.createdTime.toISOString(),
+                    modifiedTime: f.modifiedTime.toISOString(),
+                })),
+            },
+        };
+    }
+    async getFile(fileId) {
+        if (!fileId) {
+            return { success: false, error: 'File ID is required' };
+        }
+        const file = this.files.get(fileId);
+        if (!file) {
+            return { success: false, error: 'File not found' };
+        }
+        return {
+            success: true,
+            data: {
+                id: file.id,
+                name: file.name,
+                mimeType: file.mimeType,
+                createdTime: file.createdTime.toISOString(),
+                modifiedTime: file.modifiedTime.toISOString(),
+                permissions: file.permissions,
+            },
+        };
+    }
+    async createFolder(name, parentId) {
+        if (!name) {
+            return { success: false, error: 'Folder name is required' };
+        }
+        const fileId = `folder_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const folder = {
+            id: fileId,
+            name,
+            mimeType: 'application/vnd.google-apps.folder',
+            parentId: parentId || 'root',
+            createdTime: new Date(),
+            modifiedTime: new Date(),
+            permissions: [],
+        };
+        this.files.set(fileId, folder);
+        this.logger.info('Google Drive folder created', { fileId, name });
+        return {
+            success: true,
+            data: {
+                id: fileId,
+                name,
+                mimeType: folder.mimeType,
+            },
+        };
+    }
+    async uploadFile(name, content, mimeType, parentId) {
+        if (!name || !content) {
+            return { success: false, error: 'File name and content are required' };
+        }
+        const fileId = `file_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const file = {
+            id: fileId,
+            name,
+            mimeType: mimeType || 'application/octet-stream',
+            content,
+            parentId: parentId || 'root',
+            createdTime: new Date(),
+            modifiedTime: new Date(),
+            permissions: [],
+        };
+        this.files.set(fileId, file);
+        this.logger.info('File uploaded to Google Drive', { fileId, name });
+        return {
+            success: true,
+            data: {
+                id: fileId,
+                name,
+                mimeType: file.mimeType,
+                size: content.length,
+            },
+        };
+    }
+    async downloadFile(fileId) {
+        if (!fileId) {
+            return { success: false, error: 'File ID is required' };
+        }
+        const file = this.files.get(fileId);
+        if (!file) {
+            return { success: false, error: 'File not found' };
+        }
+        if (file.mimeType === 'application/vnd.google-apps.folder') {
+            return { success: false, error: 'Cannot download a folder' };
+        }
+        return {
+            success: true,
+            data: {
+                id: file.id,
+                name: file.name,
+                mimeType: file.mimeType,
+                content: file.content,
+            },
+        };
+    }
+    async deleteFile(fileId) {
+        if (!fileId) {
+            return { success: false, error: 'File ID is required' };
+        }
+        if (fileId === 'root') {
+            return { success: false, error: 'Cannot delete root folder' };
+        }
+        const deleted = this.files.delete(fileId);
+        if (!deleted) {
+            return { success: false, error: 'File not found' };
+        }
+        this.logger.info('File deleted from Google Drive', { fileId });
+        return {
+            success: true,
+            data: { fileId, deleted: true },
+        };
+    }
+    async moveFile(fileId, newParentId) {
+        if (!fileId || !newParentId) {
+            return { success: false, error: 'File ID and new parent ID are required' };
+        }
+        const file = this.files.get(fileId);
+        if (!file) {
+            return { success: false, error: 'File not found' };
+        }
+        const newParent = this.files.get(newParentId);
+        if (!newParent || newParent.mimeType !== 'application/vnd.google-apps.folder') {
+            return { success: false, error: 'Destination folder not found' };
+        }
+        file.parentId = newParentId;
+        file.modifiedTime = new Date();
+        this.logger.info('File moved in Google Drive', { fileId, newParentId });
+        return {
+            success: true,
+            data: {
+                id: file.id,
+                name: file.name,
+                parentId: newParentId,
+            },
+        };
+    }
+    async copyFile(fileId, newName) {
+        if (!fileId) {
+            return { success: false, error: 'File ID is required' };
+        }
+        const file = this.files.get(fileId);
+        if (!file) {
+            return { success: false, error: 'File not found' };
+        }
+        const newFileId = `file_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const newFile = {
+            ...file,
+            id: newFileId,
+            name: newName || `Copy of ${file.name}`,
+            createdTime: new Date(),
+            modifiedTime: new Date(),
+            permissions: [],
+        };
+        this.files.set(newFileId, newFile);
+        this.logger.info('File copied in Google Drive', { fileId, newFileId });
+        return {
+            success: true,
+            data: {
+                id: newFileId,
+                name: newFile.name,
+                mimeType: newFile.mimeType,
+            },
+        };
+    }
+    async shareFile(fileId, email, role) {
+        if (!fileId || !email || !role) {
+            return { success: false, error: 'File ID, email, and role are required' };
+        }
+        const file = this.files.get(fileId);
+        if (!file) {
+            return { success: false, error: 'File not found' };
+        }
+        // Check if permission already exists
+        const existingIndex = file.permissions.findIndex(p => p.email === email);
+        if (existingIndex >= 0) {
+            file.permissions[existingIndex].role = role;
+        }
+        else {
+            file.permissions.push({ email, role });
+        }
+        this.logger.info('File shared in Google Drive', { fileId, email, role });
+        return {
+            success: true,
+            data: {
+                fileId,
+                email,
+                role,
+                permissionId: `perm_${Date.now()}`,
+            },
+        };
+    }
+    getFiles() {
+        return new Map(this.files);
+    }
+    clearFiles() {
+        this.files.clear();
+        // Recreate root
+        this.files.set('root', {
+            id: 'root',
+            name: 'My Drive',
+            mimeType: 'application/vnd.google-apps.folder',
+            createdTime: new Date(),
+            modifiedTime: new Date(),
+            permissions: [],
+        });
+    }
+}
+exports.GoogleDriveTool = GoogleDriveTool;
+//# sourceMappingURL=GoogleWorkspaceTool.js.map