@alanse/mcp-server-google-workspace 0.2.1 → 1.0.0

package/dist/tools/docs/content/gdocs_apply_style.js

@@ -0,0 +1,86 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+import { Validator } from "../../../lib/validation.js";
+export const schema = {
+    name: "gdocs_apply_style",
+    description: "Apply a named style (Normal, Heading 1-6, Title, Subtitle) to a paragraph range in a Google Document.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            startIndex: {
+                type: "number",
+                description: "Start position of paragraph to style (1-based, inclusive)",
+            },
+            endIndex: {
+                type: "number",
+                description: "End position of paragraph to style (1-based, exclusive)",
+            },
+            namedStyleType: {
+                type: "string",
+                description: "Named style to apply",
+                enum: [
+                    "NORMAL_TEXT",
+                    "HEADING_1",
+                    "HEADING_2",
+                    "HEADING_3",
+                    "HEADING_4",
+                    "HEADING_5",
+                    "HEADING_6",
+                    "TITLE",
+                    "SUBTITLE",
+                ],
+            },
+        },
+        required: ["documentId", "startIndex", "endIndex", "namedStyleType"],
+    },
+};
+export async function applyStyle(args) {
+    try {
+        // Validate inputs
+        if (!Validator.validateRange(args.startIndex, args.endIndex)) {
+            throw new Error("Invalid range: startIndex must be less than endIndex and both must be positive");
+        }
+        if (!Validator.validateNamedStyleType(args.namedStyleType)) {
+            throw new Error("Invalid namedStyleType. Must be one of: NORMAL_TEXT, HEADING_1-6, TITLE, SUBTITLE");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        updateParagraphStyle: {
+                            paragraphStyle: {
+                                namedStyleType: args.namedStyleType,
+                            },
+                            fields: "namedStyleType",
+                            range: {
+                                startIndex: args.startIndex,
+                                endIndex: args.endIndex,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            namedStyleType: args.namedStyleType,
+            range: {
+                startIndex: args.startIndex,
+                endIndex: args.endIndex,
+            },
+        }, `Style '${args.namedStyleType}' applied successfully`);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/content/gdocs_create_heading.js

@@ -0,0 +1,89 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+export const schema = {
+    name: "gdocs_create_heading",
+    description: "Create a heading (H1-H6) in a Google Document. If index is not provided, appends to end.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            text: {
+                type: "string",
+                description: "Heading text",
+            },
+            level: {
+                type: "number",
+                description: "Heading level (1-6, where 1 is H1, 2 is H2, etc.)",
+                enum: [1, 2, 3, 4, 5, 6],
+            },
+            index: {
+                type: "number",
+                description: "Position to insert heading (1-based). If not provided, appends to end.",
+            },
+        },
+        required: ["documentId", "text", "level"],
+    },
+};
+export async function createHeading(args) {
+    try {
+        // Validate level
+        if (![1, 2, 3, 4, 5, 6].includes(args.level)) {
+            throw new Error("Level must be between 1 and 6");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        // Determine insertion index
+        let insertIndex = args.index;
+        if (!insertIndex) {
+            const doc = await docs.documents.get({ documentId });
+            const endIndex = doc.data.body?.content?.[doc.data.body.content.length - 1]?.endIndex || 1;
+            insertIndex = endIndex - 1;
+        }
+        // Map level to named style
+        const namedStyleType = `HEADING_${args.level}`;
+        const headingText = args.text + "\n";
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        insertText: {
+                            text: headingText,
+                            location: {
+                                index: insertIndex,
+                            },
+                        },
+                    },
+                    {
+                        updateParagraphStyle: {
+                            paragraphStyle: {
+                                namedStyleType,
+                            },
+                            fields: "namedStyleType",
+                            range: {
+                                startIndex: insertIndex,
+                                endIndex: insertIndex + headingText.length,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            headingText: args.text,
+            level: args.level,
+            insertedAt: insertIndex,
+            namedStyleType,
+        }, `Heading ${args.level} created successfully`);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/content/gdocs_create_list.js

@@ -0,0 +1,86 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+import { Validator } from "../../../lib/validation.js";
+export const schema = {
+    name: "gdocs_create_list",
+    description: "Convert a range of paragraphs into a bulleted or numbered list in a Google Document.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            startIndex: {
+                type: "number",
+                description: "Start position of text to convert to list (1-based, inclusive)",
+            },
+            endIndex: {
+                type: "number",
+                description: "End position of text to convert to list (1-based, exclusive)",
+            },
+            listType: {
+                type: "string",
+                description: "Type of list to create",
+                enum: ["ORDERED", "UNORDERED"],
+            },
+            nestingLevel: {
+                type: "number",
+                description: "Nesting level of the list (0-8, default: 0)",
+            },
+        },
+        required: ["documentId", "startIndex", "endIndex", "listType"],
+    },
+};
+export async function createList(args) {
+    try {
+        // Validate inputs
+        if (!Validator.validateRange(args.startIndex, args.endIndex)) {
+            throw new Error("Invalid range: startIndex must be less than endIndex and both must be positive");
+        }
+        if (!["ORDERED", "UNORDERED"].includes(args.listType)) {
+            throw new Error("listType must be either 'ORDERED' or 'UNORDERED'");
+        }
+        const nestingLevel = args.nestingLevel || 0;
+        if (nestingLevel < 0 || nestingLevel > 8) {
+            throw new Error("nestingLevel must be between 0 and 8");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        // Map list type to glyph type
+        const glyphType = args.listType === "ORDERED" ? undefined : "GLYPH_TYPE_UNSPECIFIED";
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        createParagraphBullets: {
+                            range: {
+                                startIndex: args.startIndex,
+                                endIndex: args.endIndex,
+                            },
+                            bulletPreset: args.listType === "ORDERED"
+                                ? "NUMBERED_DECIMAL_ALPHA_ROMAN"
+                                : "BULLET_DISC_CIRCLE_SQUARE",
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            listType: args.listType,
+            range: {
+                startIndex: args.startIndex,
+                endIndex: args.endIndex,
+            },
+            nestingLevel,
+        }, `List created successfully (${args.listType.toLowerCase()})`);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/content/gdocs_delete_text.js

@@ -0,0 +1,64 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+import { Validator } from "../../../lib/validation.js";
+export const schema = {
+    name: "gdocs_delete_text",
+    description: "Delete text in a specific range from a Google Document. Indices are 1-based.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            startIndex: {
+                type: "number",
+                description: "Start position of text to delete (1-based, inclusive)",
+            },
+            endIndex: {
+                type: "number",
+                description: "End position of text to delete (1-based, exclusive)",
+            },
+        },
+        required: ["documentId", "startIndex", "endIndex"],
+    },
+};
+export async function deleteText(args) {
+    try {
+        // Validate inputs
+        if (!Validator.validateRange(args.startIndex, args.endIndex)) {
+            throw new Error("Invalid range: startIndex must be less than endIndex and both must be positive");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        deleteContentRange: {
+                            range: {
+                                startIndex: args.startIndex,
+                                endIndex: args.endIndex,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            deletedRange: {
+                startIndex: args.startIndex,
+                endIndex: args.endIndex,
+            },
+            deletedLength: args.endIndex - args.startIndex,
+        }, "Text deleted successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/content/gdocs_format_text.js

@@ -0,0 +1,137 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+import { Validator } from "../../../lib/validation.js";
+export const schema = {
+    name: "gdocs_format_text",
+    description: "Apply text formatting (bold, italic, font, color, etc.) to a range in a Google Document.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            startIndex: {
+                type: "number",
+                description: "Start position of text to format (1-based, inclusive)",
+            },
+            endIndex: {
+                type: "number",
+                description: "End position of text to format (1-based, exclusive)",
+            },
+            format: {
+                type: "object",
+                description: "Formatting options to apply",
+                properties: {
+                    bold: { type: "boolean", description: "Make text bold" },
+                    italic: { type: "boolean", description: "Make text italic" },
+                    underline: { type: "boolean", description: "Underline text" },
+                    fontSize: { type: "number", description: "Font size in points" },
+                    fontFamily: { type: "string", description: "Font family (e.g., 'Arial', 'Times New Roman')" },
+                    foregroundColor: {
+                        type: "object",
+                        description: "Text color (RGB values 0-1)",
+                        properties: {
+                            red: { type: "number" },
+                            green: { type: "number" },
+                            blue: { type: "number" },
+                        },
+                    },
+                    backgroundColor: {
+                        type: "object",
+                        description: "Background color (RGB values 0-1)",
+                        properties: {
+                            red: { type: "number" },
+                            green: { type: "number" },
+                            blue: { type: "number" },
+                        },
+                    },
+                },
+            },
+        },
+        required: ["documentId", "startIndex", "endIndex", "format"],
+    },
+};
+export async function formatText(args) {
+    try {
+        // Validate inputs
+        if (!Validator.validateRange(args.startIndex, args.endIndex)) {
+            throw new Error("Invalid range: startIndex must be less than endIndex and both must be positive");
+        }
+        if (!Validator.validateTextStyle(args.format)) {
+            throw new Error("Invalid format: at least one formatting property must be specified");
+        }
+        // Validate colors if provided
+        if (args.format.foregroundColor && !Validator.validateColor(args.format.foregroundColor)) {
+            throw new Error("Invalid foregroundColor: RGB values must be between 0 and 1");
+        }
+        if (args.format.backgroundColor && !Validator.validateColor(args.format.backgroundColor)) {
+            throw new Error("Invalid backgroundColor: RGB values must be between 0 and 1");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        // Build text style object
+        const textStyle = {};
+        if (args.format.bold !== undefined)
+            textStyle.bold = args.format.bold;
+        if (args.format.italic !== undefined)
+            textStyle.italic = args.format.italic;
+        if (args.format.underline !== undefined)
+            textStyle.underline = args.format.underline;
+        if (args.format.fontSize) {
+            textStyle.fontSize = {
+                magnitude: args.format.fontSize,
+                unit: "PT",
+            };
+        }
+        if (args.format.fontFamily)
+            textStyle.weightedFontFamily = { fontFamily: args.format.fontFamily };
+        if (args.format.foregroundColor) {
+            textStyle.foregroundColor = {
+                color: {
+                    rgbColor: args.format.foregroundColor,
+                },
+            };
+        }
+        if (args.format.backgroundColor) {
+            textStyle.backgroundColor = {
+                color: {
+                    rgbColor: args.format.backgroundColor,
+                },
+            };
+        }
+        // Build fields mask
+        const fields = Object.keys(textStyle).join(",");
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        updateTextStyle: {
+                            textStyle,
+                            fields,
+                            range: {
+                                startIndex: args.startIndex,
+                                endIndex: args.endIndex,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            formattedRange: {
+                startIndex: args.startIndex,
+                endIndex: args.endIndex,
+            },
+            appliedFormats: Object.keys(args.format),
+        }, "Text formatted successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/content/gdocs_insert_text.js

@@ -0,0 +1,62 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+import { Validator } from "../../../lib/validation.js";
+export const schema = {
+    name: "gdocs_insert_text",
+    description: "Insert text at a specific position in a Google Document. Position is 1-based (1 = start of document).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            text: {
+                type: "string",
+                description: "Text to insert",
+            },
+            index: {
+                type: "number",
+                description: "Position to insert text (1-based index, 1 = start of document)",
+            },
+        },
+        required: ["documentId", "text", "index"],
+    },
+};
+export async function insertText(args) {
+    try {
+        // Validate inputs
+        if (!Validator.validateIndex(args.index)) {
+            throw new Error("Index must be a positive integer");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        insertText: {
+                            text: args.text,
+                            location: {
+                                index: args.index,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            insertedText: args.text,
+            insertedAt: args.index,
+            length: args.text.length,
+        }, "Text inserted successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/content/gdocs_replace_text.js

@@ -0,0 +1,64 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+export const schema = {
+    name: "gdocs_replace_text",
+    description: "Find and replace all occurrences of text in a Google Document.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            findText: {
+                type: "string",
+                description: "Text to find",
+            },
+            replaceText: {
+                type: "string",
+                description: "Text to replace with",
+            },
+            matchCase: {
+                type: "boolean",
+                description: "Whether to match case (default: false)",
+            },
+        },
+        required: ["documentId", "findText", "replaceText"],
+    },
+};
+export async function replaceText(args) {
+    try {
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        replaceAllText: {
+                            containsText: {
+                                text: args.findText,
+                                matchCase: args.matchCase || false,
+                            },
+                            replaceText: args.replaceText,
+                        },
+                    },
+                ],
+            },
+        });
+        // Get occurrences replaced from response
+        const occurrencesReplaced = response.data.replies?.[0]?.replaceAllText?.occurrencesChanged || 0;
+        return ResponseFormatter.success({
+            documentId,
+            findText: args.findText,
+            replaceText: args.replaceText,
+            occurrencesReplaced,
+        }, `Replaced ${occurrencesReplaced} occurrence(s)`);
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}

package/dist/tools/docs/content/gdocs_set_alignment.js

@@ -0,0 +1,76 @@
+import { google } from "googleapis";
+import { ResponseFormatter } from "../../../lib/response-formatter.js";
+import { DocumentIdResolver } from "../../../lib/document-id-resolver.js";
+import { Validator } from "../../../lib/validation.js";
+export const schema = {
+    name: "gdocs_set_alignment",
+    description: "Set paragraph alignment (left, center, right, justified) for a range in a Google Document.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentId: {
+                type: "string",
+                description: "Document ID or full Google Docs URL",
+            },
+            startIndex: {
+                type: "number",
+                description: "Start position of paragraph to align (1-based, inclusive)",
+            },
+            endIndex: {
+                type: "number",
+                description: "End position of paragraph to align (1-based, exclusive)",
+            },
+            alignment: {
+                type: "string",
+                description: "Alignment type",
+                enum: ["START", "CENTER", "END", "JUSTIFIED"],
+            },
+        },
+        required: ["documentId", "startIndex", "endIndex", "alignment"],
+    },
+};
+export async function setAlignment(args) {
+    try {
+        // Validate inputs
+        if (!Validator.validateRange(args.startIndex, args.endIndex)) {
+            throw new Error("Invalid range: startIndex must be less than endIndex and both must be positive");
+        }
+        if (!Validator.validateAlignment(args.alignment)) {
+            throw new Error("alignment must be one of: START, CENTER, END, JUSTIFIED");
+        }
+        // Resolve document ID from URL if needed
+        const docRef = DocumentIdResolver.resolve(args.documentId);
+        const documentId = docRef.id;
+        const docs = google.docs("v1");
+        const response = await docs.documents.batchUpdate({
+            documentId,
+            requestBody: {
+                requests: [
+                    {
+                        updateParagraphStyle: {
+                            paragraphStyle: {
+                                alignment: args.alignment,
+                            },
+                            fields: "alignment",
+                            range: {
+                                startIndex: args.startIndex,
+                                endIndex: args.endIndex,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        return ResponseFormatter.success({
+            documentId,
+            alignment: args.alignment,
+            range: {
+                startIndex: args.startIndex,
+                endIndex: args.endIndex,
+            },
+        }, "Paragraph alignment set successfully");
+    }
+    catch (error) {
+        return ResponseFormatter.error(error);
+    }
+}