gdocs-mcp 0.1.0 → 0.2.0

package/README.md

@@ -2,7 +2,7 @@
 
 Open-source MCP server for Google Docs and Sheets. Give Claude (or any MCP-compatible AI) the ability to read, create, edit, and search your Google Docs — with OAuth tokens that never leave your machine.
 
-**Like Composio, but open-source and self-hosted.**
+**Open-source. Self-hosted. Your tokens never leave your machine.**
 
 ## Quick Start
 

package/dist/index.js

@@ -12,9 +12,14 @@ import { UpdateDocumentStyleSchema, updateDocumentStyle } from './tools/update-d
 import { UpdateDocumentSchema, updateDocument } from './tools/update-document.js';
 import { UnmergeTableCellsSchema, unmergeTableCells } from './tools/unmerge-table-cells.js';
 import { GetChartsSchema, getCharts } from './tools/get-charts.js';
+import { ApplyStylePresetSchema, applyStylePreset } from './tools/apply-style-preset.js';
+import { ExtractDocumentStylesSchema, extractDocumentStyles } from './tools/extract-document-styles.js';
+import { ListStylePresetsSchema, listStylePresets } from './tools/list-style-presets.js';
+import { SetActivePresetSchema, setActivePreset } from './tools/set-active-preset.js';
+import { DeleteStylePresetSchema, deleteStylePreset } from './tools/delete-style-preset.js';
 const server = new McpServer({
     name: 'gdocs-mcp',
-    version: '0.1.0',
+    version: '0.2.0',
 });
 function formatError(err) {
     if (err instanceof Error) {
@@ -64,10 +69,16 @@ registerTool('update_document', 'Apply batch updates to a document (insertText,
 registerTool('unmerge_table_cells', 'Unmerge previously merged cells in a document table', UnmergeTableCellsSchema, unmergeTableCells);
 // Google Sheets tools
 registerTool('get_charts', 'List all charts in a Google Sheets spreadsheet with IDs and specs', GetChartsSchema, getCharts);
+// Style preset tools
+registerTool('apply_style_preset', 'Apply a style preset to a document. Updates named styles (TITLE, HEADING_1-6, NORMAL_TEXT, SUBTITLE), document margins, and table formatting in a single API call.', ApplyStylePresetSchema, applyStylePreset);
+registerTool('extract_document_styles', 'Extract styles from a Google Doc and optionally save as a reusable preset. Returns font, size, color, spacing for all named styles, margins, and table formatting.', ExtractDocumentStylesSchema, extractDocumentStyles);
+registerTool('list_style_presets', 'List all available style presets (built-in: clean, corporate, classic, minimal + user-defined) with typography summaries.', ListStylePresetsSchema, listStylePresets);
+registerTool('set_active_preset', 'Set the active style preset. The active preset auto-applies when creating new documents.', SetActivePresetSchema, setActivePreset);
+registerTool('delete_style_preset', 'Delete a user-defined style preset. Cannot delete built-in presets.', DeleteStylePresetSchema, deleteStylePreset);
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('gdocs-mcp v0.1.0 started');
+    console.error('gdocs-mcp v0.2.0 started');
 }
 main().catch((err) => {
     console.error('Failed to start gdocs-mcp:', err);

package/dist/presets/built-in.d.ts

@@ -0,0 +1,2 @@
+import type { StylePreset } from './types.js';
+export declare const BUILT_IN_PRESETS: Record<string, StylePreset>;

package/dist/presets/built-in.js

@@ -0,0 +1,270 @@
+export const BUILT_IN_PRESETS = {
+    clean: {
+        document: {
+            marginTop: 72,
+            marginBottom: 72,
+            marginLeft: 72,
+            marginRight: 72,
+        },
+        styles: {
+            TITLE: {
+                fontFamily: 'Inter',
+                fontSize: 28,
+                bold: true,
+                color: '#1a1a2e',
+                spaceBelow: 4,
+            },
+            SUBTITLE: {
+                fontFamily: 'Inter',
+                fontSize: 13,
+                italic: true,
+                color: '#666666',
+                spaceBelow: 16,
+            },
+            HEADING_1: {
+                fontFamily: 'Inter',
+                fontSize: 22,
+                bold: true,
+                color: '#1a1a2e',
+                spaceAbove: 24,
+                spaceBelow: 8,
+                keepWithNext: true,
+            },
+            HEADING_2: {
+                fontFamily: 'Inter',
+                fontSize: 16,
+                bold: true,
+                color: '#333333',
+                spaceAbove: 18,
+                spaceBelow: 6,
+                keepWithNext: true,
+            },
+            HEADING_3: {
+                fontFamily: 'Inter',
+                fontSize: 13,
+                bold: true,
+                color: '#555555',
+                spaceAbove: 14,
+                spaceBelow: 4,
+                keepWithNext: true,
+            },
+            NORMAL_TEXT: {
+                fontFamily: 'Inter',
+                fontSize: 11,
+                color: '#1a1a1a',
+                lineSpacing: 150,
+                spaceBelow: 6,
+            },
+        },
+        table: {
+            headerBackground: '#1a1a2e',
+            headerTextColor: '#ffffff',
+            headerBold: true,
+            borderColor: '#dddddd',
+            borderWidth: 0.5,
+            alternateRowBackground: '#f9f9f9',
+            cellPadding: 5,
+        },
+    },
+    corporate: {
+        document: {
+            marginTop: 72,
+            marginBottom: 72,
+            marginLeft: 72,
+            marginRight: 72,
+        },
+        styles: {
+            TITLE: {
+                fontFamily: 'Arial',
+                fontSize: 24,
+                bold: true,
+                color: '#333333',
+                spaceBelow: 4,
+            },
+            SUBTITLE: {
+                fontFamily: 'Arial',
+                fontSize: 12,
+                italic: true,
+                color: '#666666',
+                spaceBelow: 14,
+            },
+            HEADING_1: {
+                fontFamily: 'Arial',
+                fontSize: 18,
+                bold: true,
+                color: '#333333',
+                spaceAbove: 20,
+                spaceBelow: 6,
+                keepWithNext: true,
+            },
+            HEADING_2: {
+                fontFamily: 'Arial',
+                fontSize: 14,
+                bold: true,
+                color: '#444444',
+                spaceAbove: 16,
+                spaceBelow: 4,
+                keepWithNext: true,
+            },
+            HEADING_3: {
+                fontFamily: 'Arial',
+                fontSize: 12,
+                bold: true,
+                color: '#555555',
+                spaceAbove: 12,
+                spaceBelow: 4,
+                keepWithNext: true,
+            },
+            NORMAL_TEXT: {
+                fontFamily: 'Arial',
+                fontSize: 11,
+                color: '#333333',
+                lineSpacing: 140,
+                spaceBelow: 4,
+            },
+        },
+        table: {
+            headerBackground: '#4472C4',
+            headerTextColor: '#ffffff',
+            headerBold: true,
+            borderColor: '#cccccc',
+            borderWidth: 0.5,
+            alternateRowBackground: '#f2f2f2',
+            cellPadding: 5,
+        },
+    },
+    classic: {
+        document: {
+            marginTop: 72,
+            marginBottom: 72,
+            marginLeft: 72,
+            marginRight: 72,
+        },
+        styles: {
+            TITLE: {
+                fontFamily: 'Georgia',
+                fontSize: 26,
+                bold: true,
+                color: '#1a3c6e',
+                spaceBelow: 4,
+            },
+            SUBTITLE: {
+                fontFamily: 'Garamond',
+                fontSize: 13,
+                italic: true,
+                color: '#555555',
+                spaceBelow: 16,
+            },
+            HEADING_1: {
+                fontFamily: 'Georgia',
+                fontSize: 20,
+                bold: true,
+                color: '#1a3c6e',
+                spaceAbove: 22,
+                spaceBelow: 8,
+                keepWithNext: true,
+            },
+            HEADING_2: {
+                fontFamily: 'Georgia',
+                fontSize: 15,
+                bold: true,
+                color: '#2a5a8e',
+                spaceAbove: 18,
+                spaceBelow: 6,
+                keepWithNext: true,
+            },
+            HEADING_3: {
+                fontFamily: 'Georgia',
+                fontSize: 12,
+                bold: true,
+                italic: true,
+                color: '#3a6a9e',
+                spaceAbove: 14,
+                spaceBelow: 4,
+                keepWithNext: true,
+            },
+            NORMAL_TEXT: {
+                fontFamily: 'Garamond',
+                fontSize: 11,
+                color: '#222222',
+                lineSpacing: 140,
+                spaceBelow: 6,
+            },
+        },
+        table: {
+            headerBackground: '#1a3c6e',
+            headerTextColor: '#ffffff',
+            headerBold: true,
+            borderColor: '#999999',
+            borderWidth: 0.75,
+            alternateRowBackground: '#eef3f8',
+            cellPadding: 5,
+        },
+    },
+    minimal: {
+        document: {
+            marginTop: 72,
+            marginBottom: 72,
+            marginLeft: 72,
+            marginRight: 72,
+        },
+        styles: {
+            TITLE: {
+                fontFamily: 'Roboto',
+                fontSize: 24,
+                bold: false,
+                color: '#000000',
+                spaceBelow: 4,
+            },
+            SUBTITLE: {
+                fontFamily: 'Roboto',
+                fontSize: 12,
+                color: '#888888',
+                spaceBelow: 16,
+            },
+            HEADING_1: {
+                fontFamily: 'Roboto',
+                fontSize: 18,
+                bold: false,
+                color: '#000000',
+                spaceAbove: 24,
+                spaceBelow: 8,
+                keepWithNext: true,
+            },
+            HEADING_2: {
+                fontFamily: 'Roboto',
+                fontSize: 14,
+                bold: true,
+                color: '#333333',
+                spaceAbove: 18,
+                spaceBelow: 6,
+                keepWithNext: true,
+            },
+            HEADING_3: {
+                fontFamily: 'Roboto',
+                fontSize: 11,
+                bold: true,
+                color: '#555555',
+                spaceAbove: 14,
+                spaceBelow: 4,
+                keepWithNext: true,
+            },
+            NORMAL_TEXT: {
+                fontFamily: 'Roboto',
+                fontSize: 10.5,
+                color: '#222222',
+                lineSpacing: 150,
+                spaceBelow: 6,
+            },
+        },
+        table: {
+            headerBackground: '#f5f5f5',
+            headerTextColor: '#000000',
+            headerBold: true,
+            borderColor: '#e0e0e0',
+            borderWidth: 0.5,
+            alternateRowBackground: '#fafafa',
+            cellPadding: 5,
+        },
+    },
+};

package/dist/presets/config.d.ts

@@ -0,0 +1,14 @@
+import type { StylePreset } from './types.js';
+export declare function getPreset(presetName?: string): {
+    name: string;
+    preset: StylePreset;
+};
+export declare function listAllPresets(): Record<string, {
+    source: 'built-in' | 'user';
+    preset: StylePreset;
+}>;
+export declare function listAllPresetNames(): string[];
+export declare function savePreset(name: string, preset: StylePreset): void;
+export declare function deletePreset(name: string): void;
+export declare function setActivePreset(name: string): void;
+export declare function getActivePresetName(): string | undefined;

package/dist/presets/config.js

@@ -0,0 +1,87 @@
+import fs from 'fs';
+import path from 'path';
+import { BUILT_IN_PRESETS } from './built-in.js';
+const CONFIG_DIR = path.join(process.env.HOME || '~', '.gdocs-mcp');
+const STYLES_PATH = path.join(CONFIG_DIR, 'styles.json');
+const BUILT_IN_NAMES = new Set(Object.keys(BUILT_IN_PRESETS));
+function readConfig() {
+    if (!fs.existsSync(STYLES_PATH)) {
+        return { presets: {} };
+    }
+    return JSON.parse(fs.readFileSync(STYLES_PATH, 'utf8'));
+}
+function writeConfig(config) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+    fs.writeFileSync(STYLES_PATH, JSON.stringify(config, null, 2));
+    fs.chmodSync(STYLES_PATH, 0o600);
+}
+export function getPreset(presetName) {
+    const config = readConfig();
+    const name = presetName || config.activePreset;
+    if (!name) {
+        throw new Error('No preset specified and no activePreset set. Run set_active_preset or pass a presetName.');
+    }
+    // User presets override built-ins
+    const preset = config.presets[name] || BUILT_IN_PRESETS[name];
+    if (!preset) {
+        const available = listAllPresetNames();
+        throw new Error(`Preset "${name}" not found. Available: ${available.join(', ')}`);
+    }
+    return { name, preset };
+}
+export function listAllPresets() {
+    const config = readConfig();
+    const result = {};
+    for (const [name, preset] of Object.entries(BUILT_IN_PRESETS)) {
+        result[name] = { source: 'built-in', preset };
+    }
+    // User presets override built-ins
+    for (const [name, preset] of Object.entries(config.presets)) {
+        result[name] = { source: BUILT_IN_NAMES.has(name) ? 'built-in' : 'user', preset };
+    }
+    return result;
+}
+export function listAllPresetNames() {
+    return Object.keys(listAllPresets());
+}
+export function savePreset(name, preset) {
+    const config = readConfig();
+    config.presets = { ...config.presets, [name]: preset };
+    writeConfig(config);
+}
+export function deletePreset(name) {
+    if (BUILT_IN_NAMES.has(name)) {
+        const config = readConfig();
+        if (!config.presets[name]) {
+            throw new Error(`Cannot delete built-in preset "${name}". You can override it by creating a preset with the same name.`);
+        }
+        // User override of built-in — remove the override, built-in remains
+        const { [name]: _, ...rest } = config.presets;
+        writeConfig({ ...config, presets: rest });
+        return;
+    }
+    const config = readConfig();
+    if (!config.presets[name]) {
+        throw new Error(`Preset "${name}" not found.`);
+    }
+    const { [name]: _, ...rest } = config.presets;
+    const updated = { ...config, presets: rest };
+    // Clear activePreset if it was the deleted one
+    if (config.activePreset === name) {
+        delete updated.activePreset;
+    }
+    writeConfig(updated);
+}
+export function setActivePreset(name) {
+    const allNames = listAllPresetNames();
+    if (!allNames.includes(name)) {
+        throw new Error(`Preset "${name}" not found. Available: ${allNames.join(', ')}`);
+    }
+    const config = readConfig();
+    writeConfig({ ...config, activePreset: name });
+}
+export function getActivePresetName() {
+    return readConfig().activePreset;
+}

package/dist/presets/converter.d.ts

@@ -0,0 +1,12 @@
+import type { NamedStyleConfig, DocumentStyleConfig, TableStyleConfig } from './types.js';
+export declare function buildNamedStyleRequest(styles: Record<string, NamedStyleConfig>): {
+    updateNamedStyles: any;
+};
+export declare function buildDocumentStyleRequest(config: DocumentStyleConfig): {
+    updateDocumentStyle: any;
+};
+export declare function buildTableStyleRequests(tableConfig: TableStyleConfig, tables: Array<{
+    startIndex: number;
+    rows: number;
+    cols: number;
+}>): any[];

package/dist/presets/converter.js

@@ -0,0 +1,289 @@
+function hexToRgb(hex) {
+    const h = hex.replace('#', '');
+    return {
+        red: parseInt(h.substring(0, 2), 16) / 255,
+        green: parseInt(h.substring(2, 4), 16) / 255,
+        blue: parseInt(h.substring(4, 6), 16) / 255,
+    };
+}
+function toColor(hex) {
+    return { color: { rgbColor: hexToRgb(hex) } };
+}
+function toDimension(magnitude, unit = 'PT') {
+    return { magnitude, unit };
+}
+function toBorder(config) {
+    return {
+        color: toColor(config.color),
+        width: toDimension(config.width),
+        padding: toDimension(config.padding),
+        dashStyle: 'SOLID',
+    };
+}
+export function buildNamedStyleRequest(styles) {
+    const namedStyles = [];
+    const fieldParts = new Set();
+    for (const [styleType, config] of Object.entries(styles)) {
+        const textStyle = {};
+        const paragraphStyle = {};
+        // Text style properties
+        if (config.fontFamily !== undefined) {
+            textStyle.weightedFontFamily = { fontFamily: config.fontFamily };
+            fieldParts.add('textStyle.weightedFontFamily');
+        }
+        if (config.fontSize !== undefined) {
+            textStyle.fontSize = toDimension(config.fontSize);
+            fieldParts.add('textStyle.fontSize');
+        }
+        if (config.bold !== undefined) {
+            textStyle.bold = config.bold;
+            fieldParts.add('textStyle.bold');
+        }
+        if (config.italic !== undefined) {
+            textStyle.italic = config.italic;
+            fieldParts.add('textStyle.italic');
+        }
+        if (config.underline !== undefined) {
+            textStyle.underline = config.underline;
+            fieldParts.add('textStyle.underline');
+        }
+        if (config.strikethrough !== undefined) {
+            textStyle.strikethrough = config.strikethrough;
+            fieldParts.add('textStyle.strikethrough');
+        }
+        if (config.smallCaps !== undefined) {
+            textStyle.smallCaps = config.smallCaps;
+            fieldParts.add('textStyle.smallCaps');
+        }
+        if (config.color !== undefined) {
+            textStyle.foregroundColor = toColor(config.color);
+            fieldParts.add('textStyle.foregroundColor');
+        }
+        if (config.backgroundColor !== undefined) {
+            textStyle.backgroundColor = toColor(config.backgroundColor);
+            fieldParts.add('textStyle.backgroundColor');
+        }
+        if (config.baselineOffset !== undefined) {
+            textStyle.baselineOffset = config.baselineOffset;
+            fieldParts.add('textStyle.baselineOffset');
+        }
+        // Paragraph style properties
+        if (config.alignment !== undefined) {
+            paragraphStyle.alignment = config.alignment;
+            fieldParts.add('paragraphStyle.alignment');
+        }
+        if (config.lineSpacing !== undefined) {
+            paragraphStyle.lineSpacing = config.lineSpacing;
+            fieldParts.add('paragraphStyle.lineSpacing');
+        }
+        if (config.spaceAbove !== undefined) {
+            paragraphStyle.spaceAbove = toDimension(config.spaceAbove);
+            fieldParts.add('paragraphStyle.spaceAbove');
+        }
+        if (config.spaceBelow !== undefined) {
+            paragraphStyle.spaceBelow = toDimension(config.spaceBelow);
+            fieldParts.add('paragraphStyle.spaceBelow');
+        }
+        if (config.indentFirstLine !== undefined) {
+            paragraphStyle.indentFirstLine = toDimension(config.indentFirstLine);
+            fieldParts.add('paragraphStyle.indentFirstLine');
+        }
+        if (config.indentStart !== undefined) {
+            paragraphStyle.indentStart = toDimension(config.indentStart);
+            fieldParts.add('paragraphStyle.indentStart');
+        }
+        if (config.indentEnd !== undefined) {
+            paragraphStyle.indentEnd = toDimension(config.indentEnd);
+            fieldParts.add('paragraphStyle.indentEnd');
+        }
+        if (config.keepLinesTogether !== undefined) {
+            paragraphStyle.keepLinesTogether = config.keepLinesTogether;
+            fieldParts.add('paragraphStyle.keepLinesTogether');
+        }
+        if (config.keepWithNext !== undefined) {
+            paragraphStyle.keepWithNext = config.keepWithNext;
+            fieldParts.add('paragraphStyle.keepWithNext');
+        }
+        if (config.direction !== undefined) {
+            paragraphStyle.direction = config.direction;
+            fieldParts.add('paragraphStyle.direction');
+        }
+        if (config.borderTop !== undefined) {
+            paragraphStyle.borderTop = toBorder(config.borderTop);
+            fieldParts.add('paragraphStyle.borderTop');
+        }
+        if (config.borderBottom !== undefined) {
+            paragraphStyle.borderBottom = toBorder(config.borderBottom);
+            fieldParts.add('paragraphStyle.borderBottom');
+        }
+        if (config.borderLeft !== undefined) {
+            paragraphStyle.borderLeft = toBorder(config.borderLeft);
+            fieldParts.add('paragraphStyle.borderLeft');
+        }
+        if (config.borderRight !== undefined) {
+            paragraphStyle.borderRight = toBorder(config.borderRight);
+            fieldParts.add('paragraphStyle.borderRight');
+        }
+        namedStyles.push({
+            namedStyleType: styleType,
+            textStyle: Object.keys(textStyle).length > 0 ? textStyle : undefined,
+            paragraphStyle: Object.keys(paragraphStyle).length > 0 ? paragraphStyle : undefined,
+        });
+    }
+    return {
+        updateNamedStyles: {
+            namedStyles: { styles: namedStyles },
+            fields: Array.from(fieldParts).join(','),
+        },
+    };
+}
+export function buildDocumentStyleRequest(config) {
+    const documentStyle = {};
+    const fields = [];
+    if (config.marginTop !== undefined) {
+        documentStyle.marginTop = toDimension(config.marginTop);
+        fields.push('marginTop');
+    }
+    if (config.marginBottom !== undefined) {
+        documentStyle.marginBottom = toDimension(config.marginBottom);
+        fields.push('marginBottom');
+    }
+    if (config.marginLeft !== undefined) {
+        documentStyle.marginLeft = toDimension(config.marginLeft);
+        fields.push('marginLeft');
+    }
+    if (config.marginRight !== undefined) {
+        documentStyle.marginRight = toDimension(config.marginRight);
+        fields.push('marginRight');
+    }
+    if (config.pageWidth !== undefined || config.pageHeight !== undefined) {
+        documentStyle.pageSize = {};
+        if (config.pageWidth !== undefined) {
+            documentStyle.pageSize.width = toDimension(config.pageWidth);
+            fields.push('pageSize.width');
+        }
+        if (config.pageHeight !== undefined) {
+            documentStyle.pageSize.height = toDimension(config.pageHeight);
+            fields.push('pageSize.height');
+        }
+    }
+    return {
+        updateDocumentStyle: {
+            documentStyle,
+            fields: fields.join(','),
+        },
+    };
+}
+export function buildTableStyleRequests(tableConfig, tables) {
+    const requests = [];
+    for (const table of tables) {
+        // Header row (row 0)
+        if (tableConfig.headerBackground || tableConfig.headerTextColor || tableConfig.headerBold) {
+            const cellStyle = {};
+            const cellFields = [];
+            if (tableConfig.headerBackground) {
+                cellStyle.backgroundColor = toColor(tableConfig.headerBackground);
+                cellFields.push('backgroundColor');
+            }
+            requests.push({
+                updateTableCellStyle: {
+                    tableRange: {
+                        tableCellLocation: {
+                            tableStartLocation: { index: table.startIndex },
+                            rowIndex: 0,
+                            columnIndex: 0,
+                        },
+                        rowSpan: 1,
+                        columnSpan: table.cols,
+                    },
+                    tableCellStyle: cellStyle,
+                    fields: cellFields.join(','),
+                },
+            });
+            // Bold + color for header text requires updateTextStyle on the header row range
+            // This is handled separately since tableCellStyle doesn't control text formatting
+        }
+        // Cell borders for all cells
+        if (tableConfig.borderColor || tableConfig.borderWidth) {
+            const border = {};
+            if (tableConfig.borderColor) {
+                border.color = toColor(tableConfig.borderColor);
+            }
+            if (tableConfig.borderWidth !== undefined) {
+                border.width = toDimension(tableConfig.borderWidth);
+            }
+            border.dashStyle = 'SOLID';
+            const cellStyle = {
+                borderTop: border,
+                borderBottom: border,
+                borderLeft: border,
+                borderRight: border,
+            };
+            requests.push({
+                updateTableCellStyle: {
+                    tableRange: {
+                        tableCellLocation: {
+                            tableStartLocation: { index: table.startIndex },
+                            rowIndex: 0,
+                            columnIndex: 0,
+                        },
+                        rowSpan: table.rows,
+                        columnSpan: table.cols,
+                    },
+                    tableCellStyle: cellStyle,
+                    fields: 'borderTop,borderBottom,borderLeft,borderRight',
+                },
+            });
+        }
+        // Cell padding for all cells
+        if (tableConfig.cellPadding !== undefined) {
+            const padding = toDimension(tableConfig.cellPadding);
+            requests.push({
+                updateTableCellStyle: {
+                    tableRange: {
+                        tableCellLocation: {
+                            tableStartLocation: { index: table.startIndex },
+                            rowIndex: 0,
+                            columnIndex: 0,
+                        },
+                        rowSpan: table.rows,
+                        columnSpan: table.cols,
+                    },
+                    tableCellStyle: {
+                        paddingTop: padding,
+                        paddingBottom: padding,
+                        paddingLeft: padding,
+                        paddingRight: padding,
+                    },
+                    fields: 'paddingTop,paddingBottom,paddingLeft,paddingRight',
+                },
+            });
+        }
+        // Alternating row backgrounds (rows 1+)
+        if (tableConfig.alternateRowBackground && table.rows > 1) {
+            for (let row = 1; row < table.rows; row++) {
+                const bg = row % 2 === 0
+                    ? tableConfig.alternateRowBackground
+                    : '#ffffff';
+                requests.push({
+                    updateTableCellStyle: {
+                        tableRange: {
+                            tableCellLocation: {
+                                tableStartLocation: { index: table.startIndex },
+                                rowIndex: row,
+                                columnIndex: 0,
+                            },
+                            rowSpan: 1,
+                            columnSpan: table.cols,
+                        },
+                        tableCellStyle: {
+                            backgroundColor: toColor(bg),
+                        },
+                        fields: 'backgroundColor',
+                    },
+                });
+            }
+        }
+    }
+    return requests;
+}

package/dist/presets/types.d.ts

@@ -0,0 +1,59 @@
+export interface ParagraphBorderConfig {
+    color: string;
+    width: number;
+    padding: number;
+}
+export interface NamedStyleConfig {
+    fontFamily?: string;
+    fontSize?: number;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    smallCaps?: boolean;
+    color?: string;
+    backgroundColor?: string;
+    baselineOffset?: 'NONE' | 'SUPERSCRIPT' | 'SUBSCRIPT';
+    alignment?: 'START' | 'CENTER' | 'END' | 'JUSTIFIED';
+    lineSpacing?: number;
+    spaceAbove?: number;
+    spaceBelow?: number;
+    indentFirstLine?: number;
+    indentStart?: number;
+    indentEnd?: number;
+    keepLinesTogether?: boolean;
+    keepWithNext?: boolean;
+    direction?: 'LEFT_TO_RIGHT' | 'RIGHT_TO_LEFT';
+    borderTop?: ParagraphBorderConfig;
+    borderBottom?: ParagraphBorderConfig;
+    borderLeft?: ParagraphBorderConfig;
+    borderRight?: ParagraphBorderConfig;
+}
+export interface DocumentStyleConfig {
+    marginTop?: number;
+    marginBottom?: number;
+    marginLeft?: number;
+    marginRight?: number;
+    pageWidth?: number;
+    pageHeight?: number;
+}
+export interface TableStyleConfig {
+    headerBackground?: string;
+    headerTextColor?: string;
+    headerBold?: boolean;
+    borderColor?: string;
+    borderWidth?: number;
+    cellPadding?: number;
+    alternateRowBackground?: string;
+}
+export interface StylePreset {
+    document?: DocumentStyleConfig;
+    styles?: Record<string, NamedStyleConfig>;
+    table?: TableStyleConfig;
+}
+export interface StylesConfig {
+    activePreset?: string;
+    presets: Record<string, StylePreset>;
+}
+export type NamedStyleType = 'TITLE' | 'SUBTITLE' | 'HEADING_1' | 'HEADING_2' | 'HEADING_3' | 'HEADING_4' | 'HEADING_5' | 'HEADING_6' | 'NORMAL_TEXT';
+export declare const VALID_NAMED_STYLE_TYPES: NamedStyleType[];

package/dist/presets/types.js

@@ -0,0 +1,6 @@
+export const VALID_NAMED_STYLE_TYPES = [
+    'TITLE', 'SUBTITLE',
+    'HEADING_1', 'HEADING_2', 'HEADING_3',
+    'HEADING_4', 'HEADING_5', 'HEADING_6',
+    'NORMAL_TEXT',
+];

package/dist/tools/apply-style-preset.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const ApplyStylePresetSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    presetName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function applyStylePreset(args: z.infer<typeof ApplyStylePresetSchema>): Promise<{
+    documentId: string;
+    presetName: string;
+    applied: boolean;
+    reason: string;
+    requestCount?: undefined;
+} | {
+    documentId: string;
+    presetName: string;
+    applied: boolean;
+    requestCount: number;
+    reason?: undefined;
+}>;

package/dist/tools/apply-style-preset.js

@@ -0,0 +1,208 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { getAuthClient } from '../auth/google-auth.js';
+import { getPreset } from '../presets/config.js';
+import { buildDocumentStyleRequest, buildTableStyleRequests } from '../presets/converter.js';
+export const ApplyStylePresetSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID'),
+    presetName: z.string().optional().describe('Name of the preset to apply. If omitted, uses the active preset from styles.json.'),
+});
+export async function applyStylePreset(args) {
+    const auth = getAuthClient();
+    const docs = google.docs({ version: 'v1', auth });
+    const { name, preset } = getPreset(args.presetName);
+    // Read document to get paragraph structure and tables
+    const doc = await docs.documents.get({ documentId: args.documentId });
+    const content = doc.data.body?.content || [];
+    const requests = [];
+    // 1. Apply named styles by finding paragraphs of each type and updating them
+    if (preset.styles && Object.keys(preset.styles).length > 0) {
+        const paragraphsByStyle = groupParagraphsByStyle(content);
+        for (const [styleType, config] of Object.entries(preset.styles)) {
+            const paragraphs = paragraphsByStyle[styleType] || [];
+            if (paragraphs.length === 0)
+                continue;
+            for (const para of paragraphs) {
+                const textStyleReq = buildTextStyleRequest(config, para.startIndex, para.endIndex);
+                if (textStyleReq)
+                    requests.push(textStyleReq);
+                const paraStyleReq = buildParagraphStyleRequest(config, para.startIndex, para.endIndex);
+                if (paraStyleReq)
+                    requests.push(paraStyleReq);
+            }
+        }
+    }
+    // 2. Document style (margins, page size)
+    if (preset.document && Object.keys(preset.document).length > 0) {
+        requests.push(buildDocumentStyleRequest(preset.document));
+    }
+    // 3. Table styles
+    if (preset.table && Object.keys(preset.table).length > 0) {
+        const tables = extractTables(content);
+        if (tables.length > 0) {
+            const tableRequests = buildTableStyleRequests(preset.table, tables);
+            requests.push(...tableRequests);
+        }
+    }
+    if (requests.length === 0) {
+        return { documentId: args.documentId, presetName: name, applied: false, reason: 'Preset has no style definitions or document has no matching content' };
+    }
+    await docs.documents.batchUpdate({
+        documentId: args.documentId,
+        requestBody: { requests },
+    });
+    return {
+        documentId: args.documentId,
+        presetName: name,
+        applied: true,
+        requestCount: requests.length,
+    };
+}
+function hexToRgb(hex) {
+    const h = hex.replace('#', '');
+    return {
+        red: parseInt(h.substring(0, 2), 16) / 255,
+        green: parseInt(h.substring(2, 4), 16) / 255,
+        blue: parseInt(h.substring(4, 6), 16) / 255,
+    };
+}
+function toColor(hex) {
+    return { color: { rgbColor: hexToRgb(hex) } };
+}
+function toDimension(magnitude) {
+    return { magnitude, unit: 'PT' };
+}
+function buildTextStyleRequest(config, startIndex, endIndex) {
+    const textStyle = {};
+    const fields = [];
+    if (config.fontFamily !== undefined) {
+        textStyle.weightedFontFamily = { fontFamily: config.fontFamily };
+        fields.push('weightedFontFamily');
+    }
+    if (config.fontSize !== undefined) {
+        textStyle.fontSize = toDimension(config.fontSize);
+        fields.push('fontSize');
+    }
+    if (config.bold !== undefined) {
+        textStyle.bold = config.bold;
+        fields.push('bold');
+    }
+    if (config.italic !== undefined) {
+        textStyle.italic = config.italic;
+        fields.push('italic');
+    }
+    if (config.underline !== undefined) {
+        textStyle.underline = config.underline;
+        fields.push('underline');
+    }
+    if (config.strikethrough !== undefined) {
+        textStyle.strikethrough = config.strikethrough;
+        fields.push('strikethrough');
+    }
+    if (config.smallCaps !== undefined) {
+        textStyle.smallCaps = config.smallCaps;
+        fields.push('smallCaps');
+    }
+    if (config.color !== undefined) {
+        textStyle.foregroundColor = toColor(config.color);
+        fields.push('foregroundColor');
+    }
+    if (config.backgroundColor !== undefined) {
+        textStyle.backgroundColor = toColor(config.backgroundColor);
+        fields.push('backgroundColor');
+    }
+    if (config.baselineOffset !== undefined) {
+        textStyle.baselineOffset = config.baselineOffset;
+        fields.push('baselineOffset');
+    }
+    if (fields.length === 0)
+        return null;
+    return {
+        updateTextStyle: {
+            range: { startIndex, endIndex },
+            textStyle,
+            fields: fields.join(','),
+        },
+    };
+}
+function buildParagraphStyleRequest(config, startIndex, endIndex) {
+    const paragraphStyle = {};
+    const fields = [];
+    if (config.alignment !== undefined) {
+        paragraphStyle.alignment = config.alignment;
+        fields.push('alignment');
+    }
+    if (config.lineSpacing !== undefined) {
+        paragraphStyle.lineSpacing = config.lineSpacing;
+        fields.push('lineSpacing');
+    }
+    if (config.spaceAbove !== undefined) {
+        paragraphStyle.spaceAbove = toDimension(config.spaceAbove);
+        fields.push('spaceAbove');
+    }
+    if (config.spaceBelow !== undefined) {
+        paragraphStyle.spaceBelow = toDimension(config.spaceBelow);
+        fields.push('spaceBelow');
+    }
+    if (config.indentFirstLine !== undefined) {
+        paragraphStyle.indentFirstLine = toDimension(config.indentFirstLine);
+        fields.push('indentFirstLine');
+    }
+    if (config.indentStart !== undefined) {
+        paragraphStyle.indentStart = toDimension(config.indentStart);
+        fields.push('indentStart');
+    }
+    if (config.indentEnd !== undefined) {
+        paragraphStyle.indentEnd = toDimension(config.indentEnd);
+        fields.push('indentEnd');
+    }
+    if (config.keepLinesTogether !== undefined) {
+        paragraphStyle.keepLinesTogether = config.keepLinesTogether;
+        fields.push('keepLinesTogether');
+    }
+    if (config.keepWithNext !== undefined) {
+        paragraphStyle.keepWithNext = config.keepWithNext;
+        fields.push('keepWithNext');
+    }
+    if (config.direction !== undefined) {
+        paragraphStyle.direction = config.direction;
+        fields.push('direction');
+    }
+    if (fields.length === 0)
+        return null;
+    return {
+        updateParagraphStyle: {
+            range: { startIndex, endIndex },
+            paragraphStyle,
+            fields: fields.join(','),
+        },
+    };
+}
+function groupParagraphsByStyle(content) {
+    const groups = {};
+    for (const element of content) {
+        if (!element.paragraph)
+            continue;
+        const styleType = element.paragraph.paragraphStyle?.namedStyleType || 'NORMAL_TEXT';
+        if (!groups[styleType])
+            groups[styleType] = [];
+        groups[styleType].push({
+            startIndex: element.startIndex || 0,
+            endIndex: element.endIndex || 0,
+        });
+    }
+    return groups;
+}
+function extractTables(content) {
+    const tables = [];
+    for (const element of content) {
+        if (element.table) {
+            tables.push({
+                startIndex: element.startIndex,
+                rows: element.table.rows || 0,
+                cols: element.table.columns || 0,
+            });
+        }
+    }
+    return tables;
+}

package/dist/tools/delete-style-preset.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const DeleteStylePresetSchema: z.ZodObject<{
+    presetName: z.ZodString;
+}, z.core.$strip>;
+export declare function deleteStylePreset(args: z.infer<typeof DeleteStylePresetSchema>): Promise<{
+    deleted: string;
+    message: string;
+}>;

package/dist/tools/delete-style-preset.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { deletePreset } from '../presets/config.js';
+export const DeleteStylePresetSchema = z.object({
+    presetName: z.string().describe('Name of the preset to delete. Cannot delete built-in presets (clean, corporate, classic, minimal).'),
+});
+export async function deleteStylePreset(args) {
+    deletePreset(args.presetName);
+    return {
+        deleted: args.presetName,
+        message: `Preset "${args.presetName}" deleted.`,
+    };
+}

package/dist/tools/extract-document-styles.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import type { StylePreset } from '../presets/types.js';
+export declare const ExtractDocumentStylesSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    saveAs: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function extractDocumentStyles(args: z.infer<typeof ExtractDocumentStylesSchema>): Promise<{
+    documentId: string;
+    title: string | null | undefined;
+    preset: StylePreset;
+    savedAs: string | null;
+}>;

package/dist/tools/extract-document-styles.js

@@ -0,0 +1,149 @@
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { getAuthClient } from '../auth/google-auth.js';
+import { savePreset } from '../presets/config.js';
+import { VALID_NAMED_STYLE_TYPES } from '../presets/types.js';
+export const ExtractDocumentStylesSchema = z.object({
+    documentId: z.string().describe('The Google Doc document ID to extract styles from'),
+    saveAs: z.string().optional().describe('If provided, saves the extracted styles as a named preset in ~/.gdocs-mcp/styles.json'),
+});
+export async function extractDocumentStyles(args) {
+    const auth = getAuthClient();
+    const docs = google.docs({ version: 'v1', auth });
+    const doc = await docs.documents.get({ documentId: args.documentId });
+    const preset = {
+        document: extractDocumentStyle(doc.data.documentStyle),
+        styles: extractNamedStyles(doc.data.namedStyles),
+        table: extractTableStyles(doc.data.body?.content || []),
+    };
+    if (args.saveAs) {
+        savePreset(args.saveAs, preset);
+    }
+    return {
+        documentId: args.documentId,
+        title: doc.data.title,
+        preset,
+        savedAs: args.saveAs || null,
+    };
+}
+function extractDocumentStyle(docStyle) {
+    const config = {};
+    if (docStyle?.marginTop?.magnitude !== undefined)
+        config.marginTop = docStyle.marginTop.magnitude;
+    if (docStyle?.marginBottom?.magnitude !== undefined)
+        config.marginBottom = docStyle.marginBottom.magnitude;
+    if (docStyle?.marginLeft?.magnitude !== undefined)
+        config.marginLeft = docStyle.marginLeft.magnitude;
+    if (docStyle?.marginRight?.magnitude !== undefined)
+        config.marginRight = docStyle.marginRight.magnitude;
+    if (docStyle?.pageSize?.width?.magnitude !== undefined)
+        config.pageWidth = docStyle.pageSize.width.magnitude;
+    if (docStyle?.pageSize?.height?.magnitude !== undefined)
+        config.pageHeight = docStyle.pageSize.height.magnitude;
+    return config;
+}
+function extractNamedStyles(namedStyles) {
+    const result = {};
+    if (!namedStyles?.styles)
+        return result;
+    for (const style of namedStyles.styles) {
+        const type = style.namedStyleType;
+        if (!VALID_NAMED_STYLE_TYPES.includes(type))
+            continue;
+        const config = {};
+        const ts = style.textStyle || {};
+        const ps = style.paragraphStyle || {};
+        // Text style
+        if (ts.weightedFontFamily?.fontFamily)
+            config.fontFamily = ts.weightedFontFamily.fontFamily;
+        if (ts.fontSize?.magnitude !== undefined)
+            config.fontSize = ts.fontSize.magnitude;
+        if (ts.bold !== undefined)
+            config.bold = ts.bold;
+        if (ts.italic !== undefined)
+            config.italic = ts.italic;
+        if (ts.underline !== undefined)
+            config.underline = ts.underline;
+        if (ts.strikethrough !== undefined)
+            config.strikethrough = ts.strikethrough;
+        if (ts.smallCaps !== undefined)
+            config.smallCaps = ts.smallCaps;
+        if (ts.foregroundColor?.color?.rgbColor)
+            config.color = rgbToHex(ts.foregroundColor.color.rgbColor);
+        if (ts.backgroundColor?.color?.rgbColor)
+            config.backgroundColor = rgbToHex(ts.backgroundColor.color.rgbColor);
+        if (ts.baselineOffset)
+            config.baselineOffset = ts.baselineOffset;
+        // Paragraph style
+        if (ps.alignment)
+            config.alignment = ps.alignment;
+        if (ps.lineSpacing !== undefined)
+            config.lineSpacing = ps.lineSpacing;
+        if (ps.spaceAbove?.magnitude !== undefined)
+            config.spaceAbove = ps.spaceAbove.magnitude;
+        if (ps.spaceBelow?.magnitude !== undefined)
+            config.spaceBelow = ps.spaceBelow.magnitude;
+        if (ps.indentFirstLine?.magnitude !== undefined)
+            config.indentFirstLine = ps.indentFirstLine.magnitude;
+        if (ps.indentStart?.magnitude !== undefined)
+            config.indentStart = ps.indentStart.magnitude;
+        if (ps.indentEnd?.magnitude !== undefined)
+            config.indentEnd = ps.indentEnd.magnitude;
+        if (ps.keepLinesTogether !== undefined)
+            config.keepLinesTogether = ps.keepLinesTogether;
+        if (ps.keepWithNext !== undefined)
+            config.keepWithNext = ps.keepWithNext;
+        if (ps.direction)
+            config.direction = ps.direction;
+        if (Object.keys(config).length > 0) {
+            result[type] = config;
+        }
+    }
+    return result;
+}
+function extractTableStyles(content) {
+    // Find first table and extract its styling as the template
+    for (const element of content) {
+        if (!element.table)
+            continue;
+        const table = element.table;
+        const firstRow = table.tableRows?.[0];
+        if (!firstRow)
+            continue;
+        const config = {};
+        const firstCell = firstRow.tableCells?.[0];
+        if (firstCell?.tableCellStyle) {
+            const cs = firstCell.tableCellStyle;
+            if (cs.backgroundColor?.color?.rgbColor) {
+                config.headerBackground = rgbToHex(cs.backgroundColor.color.rgbColor);
+            }
+            if (cs.borderTop?.width?.magnitude !== undefined) {
+                config.borderWidth = cs.borderTop.width.magnitude;
+            }
+            if (cs.borderTop?.color?.color?.rgbColor) {
+                config.borderColor = rgbToHex(cs.borderTop.color.color.rgbColor);
+            }
+            if (cs.paddingTop?.magnitude !== undefined) {
+                config.cellPadding = cs.paddingTop.magnitude;
+            }
+        }
+        // Check second row for alternating background
+        if (table.tableRows?.length > 2) {
+            const thirdRow = table.tableRows[2];
+            const thirdCell = thirdRow?.tableCells?.[0];
+            if (thirdCell?.tableCellStyle?.backgroundColor?.color?.rgbColor) {
+                config.alternateRowBackground = rgbToHex(thirdCell.tableCellStyle.backgroundColor.color.rgbColor);
+            }
+        }
+        if (Object.keys(config).length > 0)
+            return config;
+        break;
+    }
+    return undefined;
+}
+function rgbToHex(rgb) {
+    const r = Math.round((rgb.red || 0) * 255);
+    const g = Math.round((rgb.green || 0) * 255);
+    const b = Math.round((rgb.blue || 0) * 255);
+    return '#' + [r, g, b].map(c => c.toString(16).padStart(2, '0')).join('');
+}

package/dist/tools/list-style-presets.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const ListStylePresetsSchema: z.ZodObject<{}, z.core.$strip>;
+export declare function listStylePresets(): Promise<{
+    activePreset: string;
+    presets: {
+        name: string;
+        source: "built-in" | "user";
+        isActive: boolean;
+        summary: {
+            bodyFont: string;
+            bodySize: string | number;
+            headingFont: string;
+            headingColor: string;
+            lineSpacing: string | number;
+        };
+    }[];
+    count: number;
+}>;

package/dist/tools/list-style-presets.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { listAllPresets, getActivePresetName } from '../presets/config.js';
+export const ListStylePresetsSchema = z.object({});
+export async function listStylePresets() {
+    const presets = listAllPresets();
+    const activePreset = getActivePresetName();
+    const result = Object.entries(presets).map(([name, { source, preset }]) => {
+        const styles = preset.styles || {};
+        const normalText = styles.NORMAL_TEXT || {};
+        const heading1 = styles.HEADING_1 || {};
+        return {
+            name,
+            source,
+            isActive: name === activePreset,
+            summary: {
+                bodyFont: normalText.fontFamily || 'default',
+                bodySize: normalText.fontSize || 'default',
+                headingFont: heading1.fontFamily || normalText.fontFamily || 'default',
+                headingColor: heading1.color || 'default',
+                lineSpacing: normalText.lineSpacing || 'default',
+            },
+        };
+    });
+    return {
+        activePreset: activePreset || 'none',
+        presets: result,
+        count: result.length,
+    };
+}

package/dist/tools/set-active-preset.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const SetActivePresetSchema: z.ZodObject<{
+    presetName: z.ZodString;
+}, z.core.$strip>;
+export declare function setActivePreset(args: z.infer<typeof SetActivePresetSchema>): Promise<{
+    activePreset: string;
+    message: string;
+}>;

package/dist/tools/set-active-preset.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { setActivePreset as setActive } from '../presets/config.js';
+export const SetActivePresetSchema = z.object({
+    presetName: z.string().describe('Name of the preset to set as active. The active preset auto-applies when creating new documents.'),
+});
+export async function setActivePreset(args) {
+    setActive(args.presetName);
+    return {
+        activePreset: args.presetName,
+        message: `Active preset set to "${args.presetName}". New documents will use this preset automatically.`,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdocs-mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Open-source MCP server for Google Docs and Sheets. Self-hosted, local OAuth, no third-party token storage.",
   "type": "module",
   "main": "dist/index.js",
@@ -30,7 +30,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/apurwa-sudo/gdocs-mcp"
+    "url": "https://github.com/Apurwa/gdocs-mcp"
   },
   "engines": {
     "node": ">=18"