gdocs-mcp 0.5.0 → 0.5.1

package/dist/tools/write-table.js

@@ -5,8 +5,11 @@ import { getPreset } from '../presets/config.js';
 const DEFAULT_HEADER_BG = { red: 0.043, green: 0.325, blue: 0.58 };
 const DEFAULT_HEADER_TEXT = { red: 0.95, green: 0.95, blue: 0.95 };
 const DEFAULT_PADDING = 5;
-const USABLE_PAGE_WIDTH = 468; // 612 - 72 - 72 (letter, 1in margins)
-const MAX_COL_RATIO = 0.35;
+const DEFAULT_PAGE_WIDTH = 612;
+const DEFAULT_MARGIN = 72;
+const DEFAULT_FONT_FAMILY = 'Arial';
+const DEFAULT_FONT_SIZE = 11;
+const DEFAULT_LINE_SPACING = 115;
 const PT_PER_CHAR = 6;
 const PADDING_PER_COL = 20;
 export const WriteTableSchema = z.object({
@@ -33,16 +36,31 @@ export async function writeTable(args) {
     const docs = google.docs({ version: 'v1', auth });
     const apiStart = performance.now();
     const colCount = args.headers.length;
-    const rowCount = args.rows.length + 1; // headers + data rows
+    const rowCount = args.rows.length + 1;
     if (colCount > 20 || rowCount > 20) {
         throw new Error(`Table exceeds Google Docs limit of 20x20. Requested: ${rowCount} rows x ${colCount} columns.`);
     }
-    // Validate row lengths match header count
     for (let i = 0; i < args.rows.length; i++) {
         if (args.rows[i].length !== colCount) {
             throw new Error(`Row ${i} has ${args.rows[i].length} cells but expected ${colCount} (matching headers).`);
         }
     }
+    // Step 0: Read document style for actual page dimensions + body font
+    const docMeta = await docs.documents.get({
+        documentId: args.documentId,
+        fields: 'documentStyle,namedStyles',
+    });
+    const docStyle = docMeta.data.documentStyle || {};
+    const pageWidth = docStyle.pageSize?.width?.magnitude ?? DEFAULT_PAGE_WIDTH;
+    const marginLeft = docStyle.marginLeft?.magnitude ?? DEFAULT_MARGIN;
+    const marginRight = docStyle.marginRight?.magnitude ?? DEFAULT_MARGIN;
+    const usableWidth = pageWidth - marginLeft - marginRight;
+    // Get body font from named styles
+    const namedStyles = docMeta.data.namedStyles?.styles || [];
+    const normalTextStyle = namedStyles.find((s) => s.namedStyleType === 'NORMAL_TEXT');
+    const bodyFontFamily = normalTextStyle?.textStyle?.weightedFontFamily?.fontFamily ?? DEFAULT_FONT_FAMILY;
+    const bodyFontSize = normalTextStyle?.textStyle?.fontSize?.magnitude ?? DEFAULT_FONT_SIZE;
+    const bodyLineSpacing = normalTextStyle?.paragraphStyle?.lineSpacing ?? DEFAULT_LINE_SPACING;
     // Step 1: Insert empty table
     await docs.documents.batchUpdate({
         documentId: args.documentId,
@@ -68,7 +86,7 @@ export async function writeTable(args) {
             'Document may have been modified concurrently.');
     }
     const tableStartIndex = table.startIndex;
-    // Build all cell data: [row][col] = { insertIndex, text }
+    // Build all cell data
     const allData = [args.headers, ...args.rows];
     const cellInserts = [];
     for (let r = 0; r < table.table.tableRows.length; r++) {
@@ -78,23 +96,21 @@ export async function writeTable(args) {
             cellInserts.push({ index: insertAt, text: allData[r][c] });
         }
     }
-    // Step 3: Build all requests — insert text (reverse order), then style
+    // Step 3: Insert text in reverse order
     const requests = [];
-    // Insert text in reverse order to avoid index shifts
     const sortedInserts = [...cellInserts].sort((a, b) => b.index - a.index);
     for (const { index, text } of sortedInserts) {
         if (text) {
             requests.push({ insertText: { location: { index }, text } });
         }
     }
-    // Execute text insertion first (indices shift after this)
     if (requests.length > 0) {
         await docs.documents.batchUpdate({
             documentId: args.documentId,
             requestBody: { requests },
         });
     }
-    // Step 4: Re-read again for styling (indices changed after text insertion)
+    // Step 4: Re-read for styling
     const doc2 = await docs.documents.get({ documentId: args.documentId });
     let table2 = null;
     for (const element of doc2.data.body?.content || []) {
@@ -103,7 +119,6 @@ export async function writeTable(args) {
             break;
         }
     }
-    // Find nearest table if exact match failed (startIndex may have shifted)
     if (!table2) {
         for (const element of doc2.data.body?.content || []) {
             if (element.table && element.startIndex != null && element.startIndex >= args.index) {
@@ -115,25 +130,42 @@ export async function writeTable(args) {
     if (!table2) {
         return { documentId: args.documentId, tableCreated: true, styled: false, reason: 'Could not re-locate table for styling' };
     }
-    // Resolve style
     const resolvedStyle = resolveStyle(args.style);
     const styleRequests = [];
-    // Bold header text + white color
-    const headerRow = table2.table.tableRows[0];
-    for (const cell of headerRow.tableCells) {
-        const start = cell.content[0].startIndex;
-        const end = cell.content[cell.content.length - 1].endIndex - 1;
-        if (end > start) {
+    // FIX 1 + 3: Apply explicit font to ALL cells (header + body)
+    for (let r = 0; r < table2.table.tableRows.length; r++) {
+        for (const cell of table2.table.tableRows[r].tableCells) {
+            const start = cell.content[0].startIndex;
+            const end = cell.content[cell.content.length - 1].endIndex - 1;
+            if (end <= start)
+                continue;
+            const isHeader = r === 0;
             styleRequests.push({
                 updateTextStyle: {
                     range: { startIndex: start, endIndex: end },
                     textStyle: {
-                        bold: true,
-                        foregroundColor: { color: { rgbColor: resolvedStyle.headerTextRgb } },
+                        weightedFontFamily: { fontFamily: bodyFontFamily },
+                        fontSize: { magnitude: bodyFontSize, unit: 'PT' },
+                        bold: isHeader,
+                        foregroundColor: isHeader
+                            ? { color: { rgbColor: resolvedStyle.headerTextRgb } }
+                            : undefined,
                     },
-                    fields: 'bold,foregroundColor',
+                    fields: isHeader
+                        ? 'weightedFontFamily,fontSize,bold,foregroundColor'
+                        : 'weightedFontFamily,fontSize,bold',
                 },
             });
+            // Apply line spacing to body cells
+            if (!isHeader) {
+                styleRequests.push({
+                    updateParagraphStyle: {
+                        range: { startIndex: start, endIndex: end },
+                        paragraphStyle: { lineSpacing: bodyLineSpacing },
+                        fields: 'lineSpacing',
+                    },
+                });
+            }
         }
     }
     // Header row background
@@ -176,7 +208,7 @@ export async function writeTable(args) {
             fields: 'paddingTop,paddingBottom,paddingLeft,paddingRight',
         },
     });
-    // Content-aware column widths
+    // FIX 2 + 4: Content-aware column widths that sum to full usable page width
     const maxLengths = new Array(colCount).fill(0);
     for (const row of allData) {
         for (let c = 0; c < colCount; c++) {
@@ -185,24 +217,31 @@ export async function writeTable(args) {
     }
     const totalLen = maxLengths.reduce((a, b) => a + b, 0);
     if (totalLen > 0) {
+        // Calculate raw proportional widths
+        const rawWidths = maxLengths.map(l => {
+            const contentWidth = l * PT_PER_CHAR + PADDING_PER_COL;
+            return Math.max(contentWidth, 50); // minimum 50pt per column
+        });
+        // Scale all widths proportionally to sum to exactly usableWidth
+        const rawTotal = rawWidths.reduce((a, b) => a + b, 0);
+        const scaledWidths = rawWidths.map(w => Math.round((w / rawTotal) * usableWidth));
+        // Adjust rounding error on last column
+        const scaledTotal = scaledWidths.reduce((a, b) => a + b, 0);
+        scaledWidths[scaledWidths.length - 1] += usableWidth - scaledTotal;
         for (let c = 0; c < colCount; c++) {
-            const contentWidth = maxLengths[c] * PT_PER_CHAR + PADDING_PER_COL;
-            const maxWidth = USABLE_PAGE_WIDTH * MAX_COL_RATIO;
-            const width = Math.min(Math.max(contentWidth, 50), maxWidth);
             styleRequests.push({
                 updateTableColumnProperties: {
                     tableStartLocation: { index: table2.startIndex },
                     columnIndices: [c],
                     tableColumnProperties: {
                         widthType: 'FIXED_WIDTH',
-                        width: { magnitude: width, unit: 'PT' },
+                        width: { magnitude: scaledWidths[c], unit: 'PT' },
                     },
                     fields: 'widthType,width',
                 },
             });
         }
     }
-    // Apply all styling
     if (styleRequests.length > 0) {
         await docs.documents.batchUpdate({
             documentId: args.documentId,
@@ -225,7 +264,6 @@ function resolveStyle(explicit) {
     let headerBgRgb = DEFAULT_HEADER_BG;
     let headerTextRgb = DEFAULT_HEADER_TEXT;
     let cellPadding = DEFAULT_PADDING;
-    // Try active preset
     try {
         const { preset } = getPreset();
         if (preset.table?.headerBackground)
@@ -238,7 +276,6 @@ function resolveStyle(explicit) {
     catch {
         // No active preset, use defaults
     }
-    // Explicit overrides
     if (explicit?.headerBackground)
         headerBgRgb = hexToRgb(explicit.headerBackground);
     if (explicit?.headerTextColor)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdocs-mcp",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "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",