mcp-gsheets 1.7.1 → 1.8.1

package/README.md

@@ -1,3 +1,5 @@
+<!-- mcp-name: io.github.freema/mcp-gsheets -->
+
 # MCP Google Sheets Server
 
 <a href="https://glama.ai/mcp/servers/@freema/mcp-gsheets">
@@ -330,6 +332,8 @@ npm run dev  # Watch mode with auto-reload
 | `sheets_append_values` | Append rows after the last row of an existing table. **Default `insertDataOption` is `OVERWRITE`** — set `INSERT_ROWS` to push existing rows down | `spreadsheetId`, `range`, `values`, `valueInputOption`, `insertDataOption` |
 | `sheets_clear_values` | Clear all values in a range (preserves formatting) | `spreadsheetId`, `range` |
 | `sheets_insert_rows` | Insert blank or pre-filled rows at a specific position | `spreadsheetId`, `range` (anchor), `rows`, `position` (BEFORE/AFTER), `values` |
+| `sheets_delete_columns` | Delete one or more columns using a full-column A1 range | `spreadsheetId`, `range` (e.g. `Sheet1!B:D`) |
+| `sheets_delete_rows` | Delete one or more rows using a full-row A1 range | `spreadsheetId`, `range` (e.g. `Sheet1!2:4`) |
 | `sheets_insert_link` | Insert a hyperlink formula into a cell | `spreadsheetId`, `range`, `url`, `label` |
 | `sheets_insert_date` | Insert a date/datetime value formatted correctly into a cell | `spreadsheetId`, `range`, `date`, `format` |
 
@@ -537,6 +541,54 @@ Insert new rows at a specific position in a spreadsheet with optional data.
 }
 ```
 
+### sheets_delete_columns
+
+Delete one or more columns from a sheet using a full-column A1 range.
+
+**Parameters:**
+- `spreadsheetId` (required): The ID of the spreadsheet
+- `range` (required): Full-column A1 range to delete (e.g., "Sheet1!B:D" or "Sheet1!C:C")
+
+**Examples:**
+
+```javascript
+// Delete columns B through D from Sheet1
+{
+  "spreadsheetId": "your-spreadsheet-id",
+  "range": "Sheet1!B:D"
+}
+
+// Delete a single column from the first sheet
+{
+  "spreadsheetId": "your-spreadsheet-id",
+  "range": "C:C"
+}
+```
+
+### sheets_delete_rows
+
+Delete one or more rows from a sheet using a full-row A1 range.
+
+**Parameters:**
+- `spreadsheetId` (required): The ID of the spreadsheet
+- `range` (required): Full-row A1 range to delete (e.g., "Sheet1!2:4" or "Sheet1!3:3")
+
+**Examples:**
+
+```javascript
+// Delete rows 2 through 4 from Sheet1
+{
+  "spreadsheetId": "your-spreadsheet-id",
+  "range": "Sheet1!2:4"
+}
+
+// Delete a single row from the first sheet
+{
+  "spreadsheetId": "your-spreadsheet-id",
+  "range": "3:3"
+}
+```
+
 ## 📋 Changelog
 
 See [CHANGELOG.md](CHANGELOG.md) for a list of changes in each version.
@@ -556,4 +608,4 @@ See [CHANGELOG.md](CHANGELOG.md) for a list of changes in each version.
 
 ## 📄 License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/index.js

@@ -18085,6 +18085,8 @@ var ERROR_MESSAGES = {
   REQUIRED_NON_NEGATIVE: (field) => `${field} must be a non-negative number`,
   // Range errors
   INVALID_RANGE: 'Invalid range format. Use A1 notation (e.g., "Sheet1!A1:B10")',
+  INVALID_COLUMN_RANGE: 'Invalid column range format. Use a full-column A1 range (e.g., "Sheet1!B:D" or "Sheet1!C:C")',
+  INVALID_ROW_RANGE: 'Invalid row range format. Use a full-row A1 range (e.g., "Sheet1!2:4" or "Sheet1!3:3")',
   RANGE_REQUIRED: "range is required and must be a string",
   // Spreadsheet errors
   SPREADSHEET_ID_REQUIRED: "spreadsheetId is required and must be a string",
@@ -18257,6 +18259,105 @@ function createSheetValidator(additionalValidation, defaults) {
   );
 }
 
+// src/utils/range-helpers.ts
+function findSheetOrThrow(sheets, sheetName) {
+  const sheet = sheets.find((s) => s.properties?.title === sheetName);
+  if (!sheet) {
+    const available = sheets.map((s) => s.properties?.title).filter(Boolean).join(", ");
+    throw new Error(`Sheet "${sheetName}" not found. Available: ${available}`);
+  }
+  return sheet;
+}
+function gridRangeToA1(range) {
+  const startCol = range.startColumnIndex ?? 0;
+  const startRow = (range.startRowIndex ?? 0) + 1;
+  const endCol = (range.endColumnIndex ?? startCol + 1) - 1;
+  const endRow = range.endRowIndex ?? startRow;
+  return `${colIndexToLetter(startCol)}${startRow}:${colIndexToLetter(endCol)}${endRow}`;
+}
+function columnToIndex(column) {
+  let index = 0;
+  for (let i = 0; i < column.length; i++) {
+    index = index * 26 + (column.charCodeAt(i) - "A".charCodeAt(0) + 1);
+  }
+  return index - 1;
+}
+function parseRange(range, sheetId) {
+  const rangePart = range.includes("!") ? range.split("!")[1] : range;
+  if (!rangePart) {
+    throw new Error(`Invalid range format: ${range}`);
+  }
+  const singleCellMatch = rangePart.match(/^([A-Z]+)(\d+)$/);
+  if (singleCellMatch?.[1] && singleCellMatch[2]) {
+    const col = columnToIndex(singleCellMatch[1]);
+    const row = parseInt(singleCellMatch[2]) - 1;
+    return {
+      sheetId: sheetId ?? null,
+      startRowIndex: row,
+      endRowIndex: row + 1,
+      startColumnIndex: col,
+      endColumnIndex: col + 1
+    };
+  }
+  const rangeMatch = rangePart.match(/^([A-Z]+)(\d+):([A-Z]+)(\d+)$/);
+  if (!rangeMatch?.[1] || !rangeMatch[2] || !rangeMatch[3] || !rangeMatch[4]) {
+    throw new Error(`Invalid range format: ${range}`);
+  }
+  return {
+    sheetId: sheetId ?? null,
+    startRowIndex: parseInt(rangeMatch[2]) - 1,
+    endRowIndex: parseInt(rangeMatch[4]),
+    startColumnIndex: columnToIndex(rangeMatch[1]),
+    endColumnIndex: columnToIndex(rangeMatch[3]) + 1
+  };
+}
+async function getSheetId(sheets, spreadsheetId, sheetName) {
+  const response = await sheets.spreadsheets.get({
+    spreadsheetId,
+    fields: "sheets.properties"
+  });
+  const sheetsData = response.data.sheets || [];
+  if (sheetName) {
+    const sheet = sheetsData.find((s) => s.properties?.title === sheetName);
+    if (!sheet?.properties?.sheetId) {
+      const availableSheets = sheetsData.map((s) => s.properties?.title).filter((title) => title).join(", ");
+      throw new Error(`Sheet "${sheetName}" not found. Available sheets: ${availableSheets}`);
+    }
+    return sheet.properties.sheetId;
+  }
+  if (sheetsData.length > 0) {
+    const firstSheet = sheetsData[0];
+    if (firstSheet?.properties?.sheetId !== void 0 && firstSheet.properties.sheetId !== null) {
+      return firstSheet.properties.sheetId;
+    }
+  }
+  throw new Error("No sheets found in spreadsheet");
+}
+function extractSheetName(range) {
+  if (range.includes("!")) {
+    const parts = range.split("!");
+    let sheetName = parts[0];
+    const rangePart = parts[1] || "";
+    if (sheetName) {
+      if (sheetName.startsWith('"') && sheetName.endsWith('"') || sheetName.startsWith("'") && sheetName.endsWith("'")) {
+        sheetName = sheetName.slice(1, -1);
+      }
+      return { sheetName, range: rangePart };
+    }
+  }
+  return { range };
+}
+function colIndexToLetter(index) {
+  let result = "";
+  let n = index + 1;
+  while (n > 0) {
+    const rem = (n - 1) % 26;
+    result = String.fromCharCode(65 + rem) + result;
+    n = Math.floor((n - 1) / 26);
+  }
+  return result;
+}
+
 // src/utils/validators.ts
 function validateRequiredString(value, fieldName) {
   if (!value || typeof value !== "string") {
@@ -18623,6 +18724,30 @@ function validateInsertRowsInput(input) {
     valueInputOption
   };
 }
+function validateDeleteColumnsInput(input) {
+  validateSpreadsheetIdField(input.spreadsheetId);
+  validateRangeField(input.range);
+  const { range } = extractSheetName(input.range);
+  if (!/^[A-Z]+:[A-Z]+$/i.test(range)) {
+    throw new Error(ERROR_MESSAGES.INVALID_COLUMN_RANGE);
+  }
+  return {
+    spreadsheetId: input.spreadsheetId,
+    range: input.range
+  };
+}
+function validateDeleteRowsInput(input) {
+  validateSpreadsheetIdField(input.spreadsheetId);
+  validateRangeField(input.range);
+  const { range } = extractSheetName(input.range);
+  if (!/^\d+:\d+$/.test(range)) {
+    throw new Error(ERROR_MESSAGES.INVALID_ROW_RANGE);
+  }
+  return {
+    spreadsheetId: input.spreadsheetId,
+    range: input.range
+  };
+}
 
 // src/utils/response-helpers.ts
 function createTextResponse(text) {
@@ -19471,105 +19596,6 @@ async function handleCopyTo(input) {
   }
 }
 
-// src/utils/range-helpers.ts
-function findSheetOrThrow(sheets, sheetName) {
-  const sheet = sheets.find((s) => s.properties?.title === sheetName);
-  if (!sheet) {
-    const available = sheets.map((s) => s.properties?.title).filter(Boolean).join(", ");
-    throw new Error(`Sheet "${sheetName}" not found. Available: ${available}`);
-  }
-  return sheet;
-}
-function gridRangeToA1(range) {
-  const startCol = range.startColumnIndex ?? 0;
-  const startRow = (range.startRowIndex ?? 0) + 1;
-  const endCol = (range.endColumnIndex ?? startCol + 1) - 1;
-  const endRow = range.endRowIndex ?? startRow;
-  return `${colIndexToLetter(startCol)}${startRow}:${colIndexToLetter(endCol)}${endRow}`;
-}
-function columnToIndex(column) {
-  let index = 0;
-  for (let i = 0; i < column.length; i++) {
-    index = index * 26 + (column.charCodeAt(i) - "A".charCodeAt(0) + 1);
-  }
-  return index - 1;
-}
-function parseRange(range, sheetId) {
-  const rangePart = range.includes("!") ? range.split("!")[1] : range;
-  if (!rangePart) {
-    throw new Error(`Invalid range format: ${range}`);
-  }
-  const singleCellMatch = rangePart.match(/^([A-Z]+)(\d+)$/);
-  if (singleCellMatch?.[1] && singleCellMatch[2]) {
-    const col = columnToIndex(singleCellMatch[1]);
-    const row = parseInt(singleCellMatch[2]) - 1;
-    return {
-      sheetId: sheetId ?? null,
-      startRowIndex: row,
-      endRowIndex: row + 1,
-      startColumnIndex: col,
-      endColumnIndex: col + 1
-    };
-  }
-  const rangeMatch = rangePart.match(/^([A-Z]+)(\d+):([A-Z]+)(\d+)$/);
-  if (!rangeMatch?.[1] || !rangeMatch[2] || !rangeMatch[3] || !rangeMatch[4]) {
-    throw new Error(`Invalid range format: ${range}`);
-  }
-  return {
-    sheetId: sheetId ?? null,
-    startRowIndex: parseInt(rangeMatch[2]) - 1,
-    endRowIndex: parseInt(rangeMatch[4]),
-    startColumnIndex: columnToIndex(rangeMatch[1]),
-    endColumnIndex: columnToIndex(rangeMatch[3]) + 1
-  };
-}
-async function getSheetId(sheets, spreadsheetId, sheetName) {
-  const response = await sheets.spreadsheets.get({
-    spreadsheetId,
-    fields: "sheets.properties"
-  });
-  const sheetsData = response.data.sheets || [];
-  if (sheetName) {
-    const sheet = sheetsData.find((s) => s.properties?.title === sheetName);
-    if (!sheet?.properties?.sheetId) {
-      const availableSheets = sheetsData.map((s) => s.properties?.title).filter((title) => title).join(", ");
-      throw new Error(`Sheet "${sheetName}" not found. Available sheets: ${availableSheets}`);
-    }
-    return sheet.properties.sheetId;
-  }
-  if (sheetsData.length > 0) {
-    const firstSheet = sheetsData[0];
-    if (firstSheet?.properties?.sheetId !== void 0 && firstSheet.properties.sheetId !== null) {
-      return firstSheet.properties.sheetId;
-    }
-  }
-  throw new Error("No sheets found in spreadsheet");
-}
-function extractSheetName(range) {
-  if (range.includes("!")) {
-    const parts = range.split("!");
-    let sheetName = parts[0];
-    const rangePart = parts[1] || "";
-    if (sheetName) {
-      if (sheetName.startsWith('"') && sheetName.endsWith('"') || sheetName.startsWith("'") && sheetName.endsWith("'")) {
-        sheetName = sheetName.slice(1, -1);
-      }
-      return { sheetName, range: rangePart };
-    }
-  }
-  return { range };
-}
-function colIndexToLetter(index) {
-  let result = "";
-  let n = index + 1;
-  while (n > 0) {
-    const rem = (n - 1) % 26;
-    result = String.fromCharCode(65 + rem) + result;
-    n = Math.floor((n - 1) / 26);
-  }
-  return result;
-}
-
 // src/utils/json-parser.ts
 function parseJsonInput(input, propertyName) {
   if (input && typeof input === "string") {
@@ -20614,29 +20640,23 @@ async function handleCreateChart(input) {
       const axes = [];
       if (validatedInput.domainAxis?.title) {
         const axis = {
-          position: "BOTTOM_AXIS"
+          position: "BOTTOM_AXIS",
+          title: validatedInput.domainAxis.title
         };
-        if (validatedInput.domainAxis.title !== void 0) {
-          axis.title = validatedInput.domainAxis.title;
-        }
         axes.push(axis);
       }
       if (validatedInput.leftAxis?.title) {
         const axis = {
-          position: "LEFT_AXIS"
+          position: "LEFT_AXIS",
+          title: validatedInput.leftAxis.title
         };
-        if (validatedInput.leftAxis.title !== void 0) {
-          axis.title = validatedInput.leftAxis.title;
-        }
         axes.push(axis);
       }
       if (validatedInput.rightAxis?.title) {
         const axis = {
-          position: "RIGHT_AXIS"
+          position: "RIGHT_AXIS",
+          title: validatedInput.rightAxis.title
         };
-        if (validatedInput.rightAxis.title !== void 0) {
-          axis.title = validatedInput.rightAxis.title;
-        }
         axes.push(axis);
       }
       if (axes.length > 0) {
@@ -21394,6 +21414,150 @@ async function handleInsertRows(input) {
   }
 }
 
+// src/tools/delete-columns.ts
+var deleteColumnsTool = {
+  name: "sheets_delete_columns",
+  description: "Delete one or more columns from a Google Sheet using a full-column A1 range",
+  inputSchema: {
+    type: "object",
+    properties: {
+      spreadsheetId: {
+        type: "string",
+        description: "The ID of the spreadsheet (found in the URL after /d/)"
+      },
+      range: {
+        type: "string",
+        description: 'Full-column A1 range to delete (e.g., "Sheet1!B:D" or "Sheet1!C:C"). If sheet name is omitted, the first sheet is used'
+      }
+    },
+    required: ["spreadsheetId", "range"]
+  }
+};
+function parseColumnRange(range) {
+  const match = range.match(/^([A-Z]+):([A-Z]+)$/i);
+  if (!match?.[1] || !match[2]) {
+    throw new Error('Column range must use full-column A1 notation, e.g. "B:D" or "C:C"');
+  }
+  const startIndex = columnToIndex(match[1].toUpperCase());
+  const endIndex = columnToIndex(match[2].toUpperCase()) + 1;
+  if (endIndex <= startIndex) {
+    throw new Error("Column range end must be greater than or equal to the start column");
+  }
+  return { startIndex, endIndex };
+}
+async function handleDeleteColumns(input) {
+  try {
+    const validatedInput = validateDeleteColumnsInput(input);
+    const sheets = await getAuthenticatedClient();
+    const { sheetName, range } = extractSheetName(validatedInput.range);
+    const sheetId = await getSheetId(sheets, validatedInput.spreadsheetId, sheetName);
+    const { startIndex, endIndex } = parseColumnRange(range);
+    await sheets.spreadsheets.batchUpdate({
+      spreadsheetId: validatedInput.spreadsheetId,
+      requestBody: {
+        requests: [
+          {
+            deleteDimension: {
+              range: {
+                sheetId,
+                dimension: "COLUMNS",
+                startIndex,
+                endIndex
+              }
+            }
+          }
+        ]
+      }
+    });
+    return formatToolResponse(
+      `Successfully deleted ${endIndex - startIndex} columns in range ${validatedInput.range}`,
+      {
+        spreadsheetId: validatedInput.spreadsheetId,
+        sheetId,
+        deletedColumns: endIndex - startIndex,
+        range: validatedInput.range
+      }
+    );
+  } catch (error2) {
+    return handleError(error2);
+  }
+}
+
+// src/tools/delete-rows.ts
+var deleteRowsTool = {
+  name: "sheets_delete_rows",
+  description: "Delete one or more rows from a Google Sheet using a full-row A1 range",
+  inputSchema: {
+    type: "object",
+    properties: {
+      spreadsheetId: {
+        type: "string",
+        description: "The ID of the spreadsheet (found in the URL after /d/)"
+      },
+      range: {
+        type: "string",
+        description: 'Full-row A1 range to delete (e.g., "Sheet1!2:4" or "Sheet1!3:3"). If sheet name is omitted, the first sheet is used'
+      }
+    },
+    required: ["spreadsheetId", "range"]
+  }
+};
+function parseRowRange(range) {
+  const match = range.match(/^(\d+):(\d+)$/);
+  if (!match?.[1] || !match[2]) {
+    throw new Error('Row range must use full-row A1 notation, e.g. "2:4" or "3:3"');
+  }
+  const startRow = parseInt(match[1], 10);
+  const endRow = parseInt(match[2], 10);
+  if (Number.isNaN(startRow) || Number.isNaN(endRow) || startRow <= 0 || endRow <= 0) {
+    throw new Error("Row numbers must be positive integers");
+  }
+  if (endRow < startRow) {
+    throw new Error("Row range end must be greater than or equal to the start row");
+  }
+  return {
+    startIndex: startRow - 1,
+    endIndex: endRow
+  };
+}
+async function handleDeleteRows(input) {
+  try {
+    const validatedInput = validateDeleteRowsInput(input);
+    const sheets = await getAuthenticatedClient();
+    const { sheetName, range } = extractSheetName(validatedInput.range);
+    const sheetId = await getSheetId(sheets, validatedInput.spreadsheetId, sheetName);
+    const { startIndex, endIndex } = parseRowRange(range);
+    await sheets.spreadsheets.batchUpdate({
+      spreadsheetId: validatedInput.spreadsheetId,
+      requestBody: {
+        requests: [
+          {
+            deleteDimension: {
+              range: {
+                sheetId,
+                dimension: "ROWS",
+                startIndex,
+                endIndex
+              }
+            }
+          }
+        ]
+      }
+    });
+    return formatToolResponse(
+      `Successfully deleted ${endIndex - startIndex} rows in range ${validatedInput.range}`,
+      {
+        spreadsheetId: validatedInput.spreadsheetId,
+        sheetId,
+        deletedRows: endIndex - startIndex,
+        range: validatedInput.range
+      }
+    );
+  } catch (error2) {
+    return handleError(error2);
+  }
+}
+
 // src/tools/get-merged-cells.ts
 var inputSchema = external_exports.object({
   spreadsheetId: external_exports.string(),
@@ -21600,14 +21764,91 @@ async function handleGetSheetFormatting(input) {
   }
 }
 
+// src/utils/formula-locale.ts
+function normalizeFormulaLocale(formula) {
+  if (!formula?.startsWith("=")) {
+    return { normalized: formula, raw: formula, localeDetected: "unknown" };
+  }
+  let result = "";
+  let inString = false;
+  let hasSemicolonSeparator = false;
+  for (let i = 0; i < formula.length; i++) {
+    const char = formula[i];
+    if (char === '"') {
+      if (inString && formula[i + 1] === '"') {
+        result += '""';
+        i++;
+        continue;
+      }
+      inString = !inString;
+      result += char;
+    } else if (char === ";" && !inString) {
+      hasSemicolonSeparator = true;
+      result += ",";
+    } else {
+      result += char;
+    }
+  }
+  const localeDetected = hasSemicolonSeparator ? "semicolon" : "comma";
+  return { normalized: result, raw: formula, localeDetected };
+}
+function normalizeConditionalFormatFormulas(rule) {
+  const result = { ...rule };
+  if (result.booleanRule?.condition?.values) {
+    const rawFormulas = [];
+    result.booleanRule = {
+      ...result.booleanRule,
+      condition: {
+        ...result.booleanRule.condition,
+        values: result.booleanRule.condition.values.map((v) => {
+          if (v.userEnteredValue?.startsWith?.("=")) {
+            const { normalized, raw } = normalizeFormulaLocale(v.userEnteredValue);
+            rawFormulas.push(raw);
+            return { ...v, userEnteredValue: normalized };
+          }
+          return v;
+        })
+      }
+    };
+    if (rawFormulas.length > 0) {
+      result._formulaLocaleRaw = rawFormulas;
+    }
+  }
+  if (result.gradientRule) {
+    const rawFormulas = [];
+    const normalizeThreshold = (threshold) => {
+      if (!threshold) {
+        return threshold;
+      }
+      if (threshold.value?.startsWith?.("=")) {
+        const { normalized, raw } = normalizeFormulaLocale(threshold.value);
+        rawFormulas.push(raw);
+        return { ...threshold, value: normalized };
+      }
+      return threshold;
+    };
+    result.gradientRule = {
+      ...result.gradientRule,
+      minpoint: normalizeThreshold(result.gradientRule.minpoint),
+      midpoint: normalizeThreshold(result.gradientRule.midpoint),
+      maxpoint: normalizeThreshold(result.gradientRule.maxpoint)
+    };
+    if (rawFormulas.length > 0) {
+      result._formulaLocaleRaw = rawFormulas;
+    }
+  }
+  return result;
+}
+
 // src/tools/get-conditional-formatting-data.ts
 var inputSchema4 = external_exports.object({
   spreadsheetId: external_exports.string(),
-  sheetName: external_exports.string()
+  sheetName: external_exports.string(),
+  normalizeFormulas: external_exports.boolean().optional().default(true)
 });
 var getConditionalFormattingDataTool = {
   name: "sheets_get_conditional_formatting",
-  description: "Read conditional formatting rules and banded ranges (alternating row/column colors) for a sheet.",
+  description: 'Read conditional formatting rules and banded ranges (alternating row/column colors) for a sheet. CF formulas are normalized to English locale (semicolons \u2192 commas) by default. Each rule with a formula includes a "_formulaLocaleRaw" field with the original unmodified formula. Set normalizeFormulas:false to get raw formulas as returned by the API.',
   inputSchema: {
     type: "object",
     properties: {
@@ -21618,6 +21859,10 @@ var getConditionalFormattingDataTool = {
       sheetName: {
         type: "string",
         description: "Name of the sheet (tab) to inspect"
+      },
+      normalizeFormulas: {
+        type: "boolean",
+        description: 'Default: true. Normalize formula separators to English locale (semicolons \u2192 commas). Each normalized rule includes "_formulaLocaleRaw" with the original formula. Set to false to get formulas exactly as returned by the Google Sheets API.'
       }
     },
     required: ["spreadsheetId", "sheetName"]
@@ -21625,18 +21870,21 @@ var getConditionalFormattingDataTool = {
 };
 async function handleGetConditionalFormattingData(input) {
   try {
-    const { spreadsheetId, sheetName } = inputSchema4.parse(input);
+    const { spreadsheetId, sheetName, normalizeFormulas } = inputSchema4.parse(input);
     const sheets = await getAuthenticatedClient();
     const response = await sheets.spreadsheets.get({
       spreadsheetId,
       fields: "sheets.properties.title,sheets.properties.sheetId,sheets.conditionalFormats,sheets.bandedRanges"
     });
     const sheetData = findSheetOrThrow(response.data.sheets ?? [], sheetName);
+    const rawFormats = sheetData.conditionalFormats ?? [];
+    const conditionalFormats = normalizeFormulas ? rawFormats.map(normalizeConditionalFormatFormulas) : rawFormats;
     return formatSuccessResponse(
       {
         sheetName,
         sheetId: sheetData.properties?.sheetId,
-        conditionalFormats: sheetData.conditionalFormats ?? [],
+        formulasNormalized: normalizeFormulas,
+        conditionalFormats,
         bandedRanges: sheetData.bandedRanges ?? []
       },
       `Conditional formatting data for sheet "${sheetName}"`
@@ -21787,11 +22035,12 @@ var inputSchema5 = external_exports.object({
   includeFormattingRange: external_exports.string().optional(),
   useEffectiveFormat: external_exports.boolean().optional().default(false),
   fields: external_exports.array(external_exports.string()).optional(),
-  compactMode: external_exports.boolean().optional().default(false)
+  compactMode: external_exports.boolean().optional().default(false),
+  includeConditionalFormatting: external_exports.boolean().optional().default(true)
 });
 var getFullSheetSnapshotTool = {
   name: "sheets_get_full_sheet_snapshot",
-  description: "One-shot tool: reads all structural and formatting metadata for a sheet in a single API call. Returns: sheet properties (frozen rows/cols, dimensions, tab color), merged cells, column widths, row heights, conditional formatting, banded ranges, and optionally cell-level formatting for a specified range (includeFormattingRange). Use compactMode:true to collapse identical adjacent cells into range descriptors (90%+ smaller output). Use fields to limit which format properties are returned. Use this before programmatically recreating a sheet.",
+  description: "One-shot tool: reads all structural and formatting metadata for a sheet in a single API call. Returns: sheet properties (frozen rows/cols, dimensions, tab color), merged cells, column widths, row heights, banded ranges, and optionally cell-level formatting for a specified range (includeFormattingRange). compactMode is OFF by default \u2014 full per-cell detail is returned unless compactMode:true is provided. When compactMode is ON, adjacent cells with identical formatting are collapsed into range descriptors (90%+ smaller output). Conditional formatting rules are included by default (includeConditionalFormatting:true); set to false to exclude them. CF formulas are normalized to English locale (commas). Use fields to limit which format properties are returned. Use this before programmatically recreating a sheet.",
   inputSchema: {
     type: "object",
     properties: {
@@ -21818,7 +22067,11 @@ var getFullSheetSnapshotTool = {
       },
       compactMode: {
         type: "boolean",
-        description: "When true, adjacent cells with identical formatting are collapsed into range descriptors (run-length encoded). Reduces cell formatting output by 90%+ for typical formatted sheets. Only applies when includeFormattingRange is set."
+        description: "Default: false. Full per-cell formatting is returned unless compactMode:true is set. When true, adjacent cells with identical formatting are collapsed into range descriptors (run-length encoded), reducing output by 90%+ for typical formatted sheets. Only applies when includeFormattingRange is set."
+      },
+      includeConditionalFormatting: {
+        type: "boolean",
+        description: "Default: true. Include conditional formatting rules and banded ranges in the snapshot. CF formulas are normalized to English locale (semicolons \u2192 commas). Set to false to reduce output size when CF rules are not needed."
       }
     },
     required: ["spreadsheetId", "sheetName"]
@@ -21832,11 +22085,13 @@ async function handleGetFullSheetSnapshot(input) {
       includeFormattingRange,
       useEffectiveFormat,
       fields: formatFields,
-      compactMode
+      compactMode,
+      includeConditionalFormatting
     } = inputSchema5.parse(input);
     const sheets = await getAuthenticatedClient();
     const baseFields = "sheets.properties,sheets.merges,sheets.data.columnMetadata,sheets.data.rowMetadata,sheets.conditionalFormats,sheets.bandedRanges";
     const formatField = useEffectiveFormat ? "effectiveFormat" : "userEnteredFormat";
+    const compact = compactMode === true;
     let cellDataFields;
     if (formatFields && formatFields.length > 0) {
       cellDataFields = formatFields.map((f) => `sheets.data.rowData.values.${formatField}.${f}`).join(",");
@@ -21880,7 +22135,7 @@ async function handleGetFullSheetSnapshot(input) {
     if (includeFormattingRange && gridData.rowData) {
       const startRow = gridData.startRow ?? 0;
       const startColumn = gridData.startColumn ?? 0;
-      if (compactMode) {
+      if (compact) {
         cellFormatting = compactifyCellFormatting(
           gridData.rowData,
           startRow,
@@ -21904,6 +22159,11 @@ async function handleGetFullSheetSnapshot(input) {
         );
       }
     }
+    const rawConditionalFormats = sheetData.conditionalFormats ?? [];
+    const cfSection = includeConditionalFormatting ? {
+      conditionalFormats: rawConditionalFormats.map(normalizeConditionalFormatFormulas),
+      bandedRanges: sheetData.bandedRanges ?? []
+    } : {};
     const snapshot = {
       sheetName,
       sheetId: props.sheetId,
@@ -21917,13 +22177,12 @@ async function handleGetFullSheetSnapshot(input) {
       merges,
       columns,
       rows,
-      conditionalFormats: sheetData.conditionalFormats ?? [],
-      bandedRanges: sheetData.bandedRanges ?? [],
+      ...cfSection,
       ...cellFormatting !== null ? {
         cellFormatting: {
           range: `${sheetName}!${includeFormattingRange}`,
           formatType: formatField,
-          compact: compactMode,
+          compact,
           data: cellFormatting
         }
       } : {}
@@ -22343,6 +22602,345 @@ async function handleGetBasicFilter(input) {
   }
 }
 
+// src/tools/get-border-map.ts
+var inputSchema10 = external_exports.object({
+  spreadsheetId: external_exports.string(),
+  range: external_exports.string().describe('Range with sheet prefix, e.g. "Sheet1!A1:F10"'),
+  includeStyle: external_exports.boolean().optional().default(false)
+});
+var getBorderMapTool = {
+  name: "sheets_get_border_map",
+  description: 'Returns a visual tabular map of borders for a range. Instead of per-cell JSON with 4 separate border objects, returns compact grids showing which cells have top/bottom/left/right borders and their styles. Solves the ambiguity between "right border of cell N" vs "left border of cell N+1". Output: a horizontal-lines grid and a vertical-lines grid, each as a 2D array of line styles. Set includeStyle:true to include color and width details (larger output).',
+  inputSchema: {
+    type: "object",
+    properties: {
+      spreadsheetId: {
+        type: "string",
+        description: "The ID of the spreadsheet (found in the URL after /d/)"
+      },
+      range: {
+        type: "string",
+        description: 'Range with sheet prefix, e.g. "Sheet1!A1:F10". Sheet name is required to resolve the range correctly.'
+      },
+      includeStyle: {
+        type: "boolean",
+        description: "Default: false. When true, each border line includes color and width details. When false, only the style name (SOLID, DASHED, etc.) is shown \u2014 more compact."
+      }
+    },
+    required: ["spreadsheetId", "range"]
+  }
+};
+function encodeBorder(border, includeStyle) {
+  if (!border || border.style === "NONE" || !border.style) {
+    return null;
+  }
+  if (!includeStyle) {
+    return border.style;
+  }
+  return {
+    style: border.style,
+    ...border.colorStyle ? { colorStyle: border.colorStyle } : {},
+    ...border.color ? { color: border.color } : {},
+    ...border.width !== void 0 ? { width: border.width } : {}
+  };
+}
+async function handleGetBorderMap(input) {
+  try {
+    const { spreadsheetId, range, includeStyle } = inputSchema10.parse(input);
+    if (!range.includes("!")) {
+      throw new Error('Range must include sheet name prefix, e.g. "Sheet1!A1:F10"');
+    }
+    const { sheetName, range: rangeOnly } = extractSheetName(range);
+    if (!sheetName) {
+      throw new Error('Range must include sheet name prefix, e.g. "Sheet1!A1:F10"');
+    }
+    const rangeMatch = rangeOnly.match(/^([A-Z]+)(\d+):([A-Z]+)(\d+)$/i);
+    if (!rangeMatch) {
+      throw new Error(`Invalid range format: "${rangeOnly}". Expected e.g. "A1:F10".`);
+    }
+    const startCol = columnToIndex(rangeMatch[1].toUpperCase());
+    const startRow = parseInt(rangeMatch[2]) - 1;
+    const endCol = columnToIndex(rangeMatch[3].toUpperCase()) + 1;
+    const endRow = parseInt(rangeMatch[4]);
+    const numRows = endRow - startRow;
+    const numCols = endCol - startCol;
+    const sheets = await getAuthenticatedClient();
+    const response = await sheets.spreadsheets.get({
+      spreadsheetId,
+      ranges: [range],
+      includeGridData: true,
+      fields: "sheets.properties.title,sheets.data.startRow,sheets.data.startColumn,sheets.data.rowData.values.userEnteredFormat.borders"
+    });
+    const sheetData = (response.data.sheets ?? []).find(
+      (s) => s.properties?.title === sheetName
+    );
+    if (!sheetData) {
+      const available = (response.data.sheets ?? []).map((s) => s.properties?.title).filter(Boolean).join(", ");
+      throw new Error(`Sheet "${sheetName}" not found. Available: ${available}`);
+    }
+    const gridData = sheetData.data?.[0] ?? {};
+    const rowData = gridData.rowData ?? [];
+    const getBorder = (rowOffset, colOffset) => {
+      const row = rowData[rowOffset];
+      const cell = row?.values?.[colOffset];
+      const borders = cell?.userEnteredFormat?.borders;
+      return [
+        borders?.top ?? null,
+        borders?.bottom ?? null,
+        borders?.left ?? null,
+        borders?.right ?? null
+      ];
+    };
+    const horizontalLines = [];
+    for (let r = 0; r <= numRows; r++) {
+      const row = [];
+      for (let c = 0; c < numCols; c++) {
+        let line = null;
+        if (r > 0) {
+          const [, bottom] = getBorder(r - 1, c);
+          if (bottom?.style && bottom.style !== "NONE") {
+            line = encodeBorder(bottom, includeStyle);
+          }
+        }
+        if (r < numRows && line === null) {
+          const [top] = getBorder(r, c);
+          if (top?.style && top.style !== "NONE") {
+            line = encodeBorder(top, includeStyle);
+          }
+        }
+        row.push(line);
+      }
+      horizontalLines.push(row);
+    }
+    const verticalLines = [];
+    for (let r = 0; r < numRows; r++) {
+      const row = [];
+      for (let c = 0; c <= numCols; c++) {
+        let line = null;
+        if (c < numCols) {
+          const [, , left] = getBorder(r, c);
+          if (left?.style && left.style !== "NONE") {
+            line = encodeBorder(left, includeStyle);
+          }
+        }
+        if (c > 0 && line === null) {
+          const [, , , right] = getBorder(r, c - 1);
+          if (right?.style && right.style !== "NONE") {
+            line = encodeBorder(right, includeStyle);
+          }
+        }
+        row.push(line);
+      }
+      verticalLines.push(row);
+    }
+    const colHeaders = Array.from({ length: numCols }, (_, i) => colIndexToLetter(startCol + i));
+    const rowHeaders = Array.from({ length: numRows }, (_, i) => String(startRow + i + 1));
+    return formatSuccessResponse(
+      {
+        range,
+        sheetName,
+        dimensions: { rows: numRows, cols: numCols },
+        colHeaders,
+        rowHeaders,
+        // horizontalLines: (numRows+1) × numCols — line above each cell row
+        horizontalLines: {
+          description: "horizontalLines[r][c] = style of horizontal border line above row r at column c. r=0 \u2192 top edge, r=numRows \u2192 bottom edge.",
+          rowCount: numRows + 1,
+          colCount: numCols,
+          data: horizontalLines
+        },
+        // verticalLines: numRows × (numCols+1) — line left of each cell column
+        verticalLines: {
+          description: "verticalLines[r][c] = style of vertical border line left of column c at row r. c=0 \u2192 left edge, c=numCols \u2192 right edge.",
+          rowCount: numRows,
+          colCount: numCols + 1,
+          data: verticalLines
+        }
+      },
+      `Border map for ${range} (${numRows}\xD7${numCols} cells)`
+    );
+  } catch (error2) {
+    return handleError(error2);
+  }
+}
+
+// src/tools/compare-ranges.ts
+var inputSchema11 = external_exports.object({
+  spreadsheetId: external_exports.string(),
+  rangeA: external_exports.string().describe('First range with sheet prefix, e.g. "Sheet1!A6:Z6"'),
+  rangeB: external_exports.string().describe('Second range with sheet prefix, e.g. "Sheet1!A7:Z7"'),
+  fields: external_exports.array(external_exports.string()).optional(),
+  useEffectiveFormat: external_exports.boolean().optional().default(false)
+});
+var compareRangesTool = {
+  name: "sheets_compare_ranges",
+  description: 'Compare cell formatting between two ranges of identical dimensions. Useful for verifying repeated patterns, e.g. "do all data rows 6\u201385 have identical formatting?" or "is row 10 formatted identically to the template row 5?". Returns a diff listing only the cells and properties that differ between the two ranges. Cells are compared position-by-position; rangeA and rangeB must have the same number of rows and columns. Use fields to restrict comparison to specific format properties.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      spreadsheetId: {
+        type: "string",
+        description: "The ID of the spreadsheet (found in the URL after /d/)"
+      },
+      rangeA: {
+        type: "string",
+        description: 'First range with sheet prefix, e.g. "Sheet1!A6:Z6"'
+      },
+      rangeB: {
+        type: "string",
+        description: 'Second range with sheet prefix, e.g. "Sheet1!A7:Z7"'
+      },
+      fields: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Optional list of format property names to compare, e.g. ["backgroundColor", "textFormat"]. All format properties compared if omitted.'
+      },
+      useEffectiveFormat: {
+        type: "boolean",
+        description: "Default: false. Compare effectiveFormat (true) or userEnteredFormat (false). effectiveFormat includes conditional formatting overlays."
+      }
+    },
+    required: ["spreadsheetId", "rangeA", "rangeB"]
+  }
+};
+function parseRangeParts(range) {
+  if (!range.includes("!")) {
+    throw new Error(`Range must include sheet name prefix, e.g. "Sheet1!A1:F10". Got: "${range}"`);
+  }
+  const { sheetName, range: rangeOnly } = extractSheetName(range);
+  if (!sheetName) {
+    throw new Error(`Range must include sheet name prefix, e.g. "Sheet1!A1:F10". Got: "${range}"`);
+  }
+  const match = rangeOnly.match(/^([A-Z]+)(\d+):([A-Z]+)(\d+)$/i);
+  if (!match) {
+    throw new Error(`Invalid range format: "${rangeOnly}". Expected e.g. "A1:F10".`);
+  }
+  return {
+    sheetName,
+    startCol: columnToIndex(match[1].toUpperCase()),
+    startRow: parseInt(match[2]) - 1,
+    endCol: columnToIndex(match[3].toUpperCase()) + 1,
+    // exclusive
+    endRow: parseInt(match[4])
+    // exclusive
+  };
+}
+function getFmtKey(rowData, rowOffset, colOffset, useEffectiveFormat, fields) {
+  const row = rowData[rowOffset];
+  const cell = row?.values?.[colOffset];
+  const rawFmt = useEffectiveFormat ? cell?.effectiveFormat : cell?.userEnteredFormat;
+  if (!rawFmt) {
+    return { key: "{}", fmt: {} };
+  }
+  const fmt = extractFormatFields(rawFmt, fields);
+  return { key: JSON.stringify(fmt), fmt };
+}
+function deepDiffProperties(fmtA, fmtB) {
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(fmtA), ...Object.keys(fmtB)]);
+  const diffs = {};
+  for (const key of allKeys) {
+    const aVal = fmtA[key];
+    const bVal = fmtB[key];
+    if (JSON.stringify(aVal) !== JSON.stringify(bVal)) {
+      diffs[key] = { a: aVal ?? null, b: bVal ?? null };
+    }
+  }
+  return diffs;
+}
+async function handleCompareRanges(input) {
+  try {
+    let findGridData2 = function(parsed, rangeStr) {
+      for (const s of allSheets) {
+        if (s.properties?.title !== parsed.sheetName) {
+          continue;
+        }
+        for (const gd of s.data ?? []) {
+          const gdStartRow = gd.startRow ?? 0;
+          const gdStartCol = gd.startColumn ?? 0;
+          if (gdStartRow === parsed.startRow && gdStartCol === parsed.startCol) {
+            return gd;
+          }
+        }
+      }
+      throw new Error(`Could not locate grid data for range "${rangeStr}". Check the sheet name.`);
+    };
+    var findGridData = findGridData2;
+    const {
+      spreadsheetId,
+      rangeA,
+      rangeB,
+      fields: formatFields,
+      useEffectiveFormat
+    } = inputSchema11.parse(input);
+    const parsedA = parseRangeParts(rangeA);
+    const parsedB = parseRangeParts(rangeB);
+    const numRowsA = parsedA.endRow - parsedA.startRow;
+    const numColsA = parsedA.endCol - parsedA.startCol;
+    const numRowsB = parsedB.endRow - parsedB.startRow;
+    const numColsB = parsedB.endCol - parsedB.startCol;
+    if (numColsA !== numColsB) {
+      throw new Error(
+        `Ranges must have the same number of columns. rangeA has ${numColsA} columns, rangeB has ${numColsB}.`
+      );
+    }
+    if (numRowsA !== numRowsB) {
+      throw new Error(
+        `Ranges must have the same number of rows. rangeA has ${numRowsA} rows, rangeB has ${numRowsB}.`
+      );
+    }
+    const formatField = useEffectiveFormat ? "effectiveFormat" : "userEnteredFormat";
+    const sheets = await getAuthenticatedClient();
+    const response = await sheets.spreadsheets.get({
+      spreadsheetId,
+      ranges: [rangeA, rangeB],
+      includeGridData: true,
+      fields: `sheets.properties.title,sheets.data.startRow,sheets.data.startColumn,sheets.data.rowData.values.${formatField}`
+    });
+    const allSheets = response.data.sheets ?? [];
+    const gdA = findGridData2(parsedA, rangeA);
+    const gdB = findGridData2(parsedB, rangeB);
+    const rowDataA = gdA.rowData ?? [];
+    const rowDataB = gdB.rowData ?? [];
+    const diffs = [];
+    let equalCells = 0;
+    for (let r = 0; r < numRowsA; r++) {
+      for (let c = 0; c < numColsA; c++) {
+        const { fmt: fmtA } = getFmtKey(rowDataA, r, c, useEffectiveFormat, formatFields);
+        const { fmt: fmtB } = getFmtKey(rowDataB, r, c, useEffectiveFormat, formatFields);
+        const propDiffs = deepDiffProperties(fmtA, fmtB);
+        if (Object.keys(propDiffs).length === 0) {
+          equalCells++;
+          continue;
+        }
+        diffs.push({
+          cellA: `${colIndexToLetter(parsedA.startCol + c)}${parsedA.startRow + r + 1}`,
+          cellB: `${colIndexToLetter(parsedB.startCol + c)}${parsedB.startRow + r + 1}`,
+          diffs: propDiffs
+        });
+      }
+    }
+    const totalCells = numRowsA * numColsA;
+    const identical = diffs.length === 0;
+    return formatSuccessResponse(
+      {
+        rangeA,
+        rangeB,
+        dimensions: { rows: numRowsA, cols: numColsA, totalCells },
+        formatType: formatField,
+        fieldsCompared: formatFields ?? "all",
+        identical,
+        summary: identical ? `All ${totalCells} cells have identical formatting.` : `${diffs.length} of ${totalCells} cells differ. ${equalCells} cells are identical.`,
+        equalCells,
+        diffCount: diffs.length,
+        diffs
+      },
+      identical ? `Ranges ${rangeA} and ${rangeB} have identical formatting` : `Found ${diffs.length} formatting difference(s) between ${rangeA} and ${rangeB}`
+    );
+  } catch (error2) {
+    return handleError(error2);
+  }
+}
+
 // src/resources/index.ts
 function parseResourceUri(uri) {
   let path;
@@ -22780,6 +23378,8 @@ var toolHandlers = /* @__PURE__ */ new Map([
   ["sheets_insert_date", handleInsertDate],
   // Row operations
   ["sheets_insert_rows", handleInsertRows],
+  ["sheets_delete_columns", handleDeleteColumns],
+  ["sheets_delete_rows", handleDeleteRows],
   // READ / Snapshot tools
   ["sheets_get_merged_cells", handleGetMergedCells],
   ["sheets_get_sheet_dimensions", handleGetSheetDimensions],
@@ -22789,7 +23389,10 @@ var toolHandlers = /* @__PURE__ */ new Map([
   ["sheets_get_sheet_structure", handleGetSheetStructure],
   ["sheets_get_formatting_compact", handleGetFormattingCompact],
   ["sheets_get_data_validation", handleGetDataValidation],
-  ["sheets_get_basic_filter", handleGetBasicFilter]
+  ["sheets_get_basic_filter", handleGetBasicFilter],
+  // Border and comparison tools
+  ["sheets_get_border_map", handleGetBorderMap],
+  ["sheets_compare_ranges", handleCompareRanges]
 ]);
 var allTools = [
   checkAccessTool,
@@ -22819,6 +23422,8 @@ var allTools = [
   insertLinkTool,
   insertDateTool,
   insertRowsTool,
+  deleteColumnsTool,
+  deleteRowsTool,
   getMergedCellsTool,
   getSheetDimensionsTool,
   getSheetFormattingTool,
@@ -22827,7 +23432,9 @@ var allTools = [
   getSheetStructureTool,
   getFormattingCompactTool,
   getDataValidationTool,
-  getBasicFilterTool
+  getBasicFilterTool,
+  getBorderMapTool,
+  compareRangesTool
 ];
 async function main() {
   try {
@@ -22839,7 +23446,7 @@ async function main() {
   const server = new Server(
     {
       name: "spreadsheet",
-      version: "1.7.1"
+      version: "1.8.0"
     },
     {
       capabilities: {

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "mcp-gsheets",
-  "version": "1.7.1",
+  "version": "1.8.1",
+  "mcpName": "io.github.freema/mcp-gsheets",
   "description": "Model Context Protocol (MCP) server for Google Sheets API integration",
   "author": "freema",
   "license": "MIT",