mcp-gsheets 1.7.0 → 1.8.0

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,90 +19596,6 @@ async function handleCopyTo(input) {
   }
 }
 
-// src/utils/range-helpers.ts
-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") {
@@ -20599,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) {
@@ -21379,14 +21414,10 @@ async function handleInsertRows(input) {
   }
 }
 
-// src/tools/get-merged-cells.ts
-var inputSchema = external_exports.object({
-  spreadsheetId: external_exports.string(),
-  sheetName: external_exports.string()
-});
-var getMergedCellsTool = {
-  name: "sheets_get_merged_cells",
-  description: "Get all merged cell ranges for a specific sheet. Returns each merge as A1 notation and GridRange coordinates.",
+// 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: {
@@ -21394,66 +21425,186 @@ var getMergedCellsTool = {
         type: "string",
         description: "The ID of the spreadsheet (found in the URL after /d/)"
       },
-      sheetName: {
+      range: {
         type: "string",
-        description: "Name of the sheet (tab) to inspect"
+        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", "sheetName"]
+    required: ["spreadsheetId", "range"]
   }
 };
-function colIndexToLetter2(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);
+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"');
   }
-  return result;
-}
-function gridRangeToA1(startRowIndex, endRowIndex, startColumnIndex, endColumnIndex) {
-  const startCol = colIndexToLetter2(startColumnIndex);
-  const endCol = colIndexToLetter2(endColumnIndex - 1);
-  const startRow = startRowIndex + 1;
-  const endRow = endRowIndex;
-  return `${startCol}${startRow}:${endCol}${endRow}`;
+  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 handleGetMergedCells(input) {
+async function handleDeleteColumns(input) {
   try {
-    const { spreadsheetId, sheetName } = inputSchema.parse(input);
+    const validatedInput = validateDeleteColumnsInput(input);
     const sheets = await getAuthenticatedClient();
-    const response = await sheets.spreadsheets.get({
-      spreadsheetId,
-      fields: "sheets.properties.title,sheets.properties.sheetId,sheets.merges"
+    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
+              }
+            }
+          }
+        ]
+      }
     });
-    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 merges = (sheetData.merges ?? []).map((m) => ({
-      a1Notation: gridRangeToA1(
-        m.startRowIndex ?? 0,
-        m.endRowIndex ?? 0,
-        m.startColumnIndex ?? 0,
-        m.endColumnIndex ?? 0
-      ),
-      startRowIndex: m.startRowIndex,
-      endRowIndex: m.endRowIndex,
-      startColumnIndex: m.startColumnIndex,
-      endColumnIndex: m.endColumnIndex
-    }));
-    return formatSuccessResponse(
+    return formatToolResponse(
+      `Successfully deleted ${endIndex - startIndex} columns in range ${validatedInput.range}`,
       {
-        sheetName,
-        sheetId: sheetData.properties?.sheetId,
-        mergeCount: merges.length,
-        merges
-      },
-      `Found ${merges.length} merged range(s) in sheet "${sheetName}"`
+        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(),
+  sheetName: external_exports.string()
+});
+var getMergedCellsTool = {
+  name: "sheets_get_merged_cells",
+  description: "Get all merged cell ranges for a specific sheet. Returns each merge as A1 notation and GridRange coordinates.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      spreadsheetId: {
+        type: "string",
+        description: "The ID of the spreadsheet (found in the URL after /d/)"
+      },
+      sheetName: {
+        type: "string",
+        description: "Name of the sheet (tab) to inspect"
+      }
+    },
+    required: ["spreadsheetId", "sheetName"]
+  }
+};
+async function handleGetMergedCells(input) {
+  try {
+    const { spreadsheetId, sheetName } = inputSchema.parse(input);
+    const sheets = await getAuthenticatedClient();
+    const response = await sheets.spreadsheets.get({
+      spreadsheetId,
+      fields: "sheets.properties.title,sheets.properties.sheetId,sheets.merges"
+    });
+    const sheetData = findSheetOrThrow(response.data.sheets ?? [], sheetName);
+    const merges = (sheetData.merges ?? []).map((m) => ({
+      a1Notation: gridRangeToA1(m),
+      startRowIndex: m.startRowIndex,
+      endRowIndex: m.endRowIndex,
+      startColumnIndex: m.startColumnIndex,
+      endColumnIndex: m.endColumnIndex
+    }));
+    return formatSuccessResponse(
+      {
+        sheetName,
+        sheetId: sheetData.properties?.sheetId,
+        mergeCount: merges.length,
+        merges
+      },
+      `Found ${merges.length} merged range(s) in sheet "${sheetName}"`
     );
   } catch (error2) {
     return handleError(error2);
@@ -21491,13 +21642,7 @@ async function handleGetSheetDimensions(input) {
       spreadsheetId,
       fields: "sheets.properties,sheets.data.columnMetadata,sheets.data.rowMetadata"
     });
-    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 sheetData = findSheetOrThrow(response.data.sheets ?? [], sheetName);
     const gridProps = sheetData.properties?.gridProperties ?? {};
     const gridData = sheetData.data?.[0] ?? {};
     const columns = (gridData.columnMetadata ?? []).map(
@@ -21619,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: {
@@ -21637,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"]
@@ -21644,24 +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 = (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 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}"`
@@ -21812,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: {
@@ -21843,15 +22067,16 @@ 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"]
   }
 };
-function gridRangeToA12(startRowIndex, endRowIndex, startColumnIndex, endColumnIndex) {
-  return `${colIndexToLetter(startColumnIndex)}${startRowIndex + 1}:${colIndexToLetter(endColumnIndex - 1)}${endRowIndex}`;
-}
 async function handleGetFullSheetSnapshot(input) {
   try {
     const {
@@ -21860,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(",");
@@ -21879,23 +22106,12 @@ async function handleGetFullSheetSnapshot(input) {
       includeGridData: !!includeFormattingRange,
       fields: baseFields + cellFormattingFields
     });
-    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 sheetData = findSheetOrThrow(response.data.sheets ?? [], sheetName);
     const props = sheetData.properties;
     const gridProps = props.gridProperties ?? {};
     const gridData = sheetData.data?.[0] ?? {};
     const merges = (sheetData.merges ?? []).map((m) => ({
-      a1Notation: gridRangeToA12(
-        m.startRowIndex ?? 0,
-        m.endRowIndex ?? 0,
-        m.startColumnIndex ?? 0,
-        m.endColumnIndex ?? 0
-      ),
+      a1Notation: gridRangeToA1(m),
       startRowIndex: m.startRowIndex,
       endRowIndex: m.endRowIndex,
       startColumnIndex: m.startColumnIndex,
@@ -21919,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,
@@ -21943,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,
@@ -21956,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
         }
       } : {}
@@ -22008,13 +22228,7 @@ async function handleGetSheetStructure(input) {
       fields: "sheets.properties,sheets.merges,sheets.data.columnMetadata,sheets.data.rowMetadata"
     });
     const allSheets = response.data.sheets ?? [];
-    const sheetData = allSheets.find(
-      (s) => s.properties?.title === sheetName
-    );
-    if (!sheetData) {
-      const available = allSheets.map((s) => s.properties?.title).filter(Boolean).join(", ");
-      throw new Error(`Sheet "${sheetName}" not found. Available: ${available}`);
-    }
+    const sheetData = findSheetOrThrow(allSheets, sheetName);
     const props = sheetData.properties;
     const gridProps = props.gridProperties ?? {};
     const gridData = sheetData.data?.[0] ?? {};
@@ -22029,13 +22243,9 @@ async function handleGetSheetStructure(input) {
       (row) => row.pixelSize ?? null
     );
     const hiddenRows = (gridData.rowMetadata ?? []).map((row, i) => row.hiddenByUser ? i : -1).filter((i) => i >= 0);
-    const merges = (sheetData.merges ?? []).map((m) => {
-      const sc = m.startColumnIndex ?? 0;
-      const ec = (m.endColumnIndex ?? 1) - 1;
-      const sr = (m.startRowIndex ?? 0) + 1;
-      const er = m.endRowIndex ?? 1;
-      return `${colIndexToLetter(sc)}${sr}:${colIndexToLetter(ec)}${er}`;
-    });
+    const merges = (sheetData.merges ?? []).map(
+      (m) => gridRangeToA1(m)
+    );
     return formatSuccessResponse(
       {
         sheetName,
@@ -22122,13 +22332,7 @@ async function handleGetFormattingCompact(input) {
       fields: `sheets.properties.title,${cellDataFields},sheets.data.startRow,sheets.data.startColumn`
     });
     const allSheets = response.data.sheets ?? [];
-    const sheetData = allSheets.find(
-      (s) => s.properties?.title === sheetName
-    );
-    if (!sheetData) {
-      const available = allSheets.map((s) => s.properties?.title).filter(Boolean).join(", ");
-      throw new Error(`Sheet "${sheetName}" not found. Available: ${available}`);
-    }
+    const sheetData = findSheetOrThrow(allSheets, sheetName);
     const gridData = sheetData.data?.[0];
     if (!gridData?.rowData) {
       return formatSuccessResponse(
@@ -22188,15 +22392,6 @@ var getDataValidationTool = {
     required: ["spreadsheetId", "sheetName"]
   }
 };
-function colToLetter(col) {
-  let letter = "";
-  let c = col;
-  while (c >= 0) {
-    letter = String.fromCharCode(c % 26 + 65) + letter;
-    c = Math.floor(c / 26) - 1;
-  }
-  return letter;
-}
 function validationKey(dv) {
   return JSON.stringify({
     type: dv.condition?.type ?? null,
@@ -22272,8 +22467,8 @@ function compactifyValidation(rowData, startRow, startCol) {
             }
           }
         }
-        const topLeft = `${colToLetter(c + minCol)}${r + minRow + 1}`;
-        const bottomRight = `${colToLetter(endC + minCol)}${endR + minRow + 1}`;
+        const topLeft = `${colIndexToLetter(c + minCol)}${r + minRow + 1}`;
+        const bottomRight = `${colIndexToLetter(endC + minCol)}${endR + minRow + 1}`;
         ranges.push(topLeft === bottomRight ? topLeft : `${topLeft}:${bottomRight}`);
       }
     }
@@ -22298,13 +22493,7 @@ async function handleGetDataValidation(input) {
       includeGridData: true,
       fields: "sheets.data.rowData.values.dataValidation,sheets.data.startRow,sheets.data.startColumn,sheets.properties.title,sheets.properties.sheetId"
     });
-    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 sheetData = findSheetOrThrow(response.data.sheets ?? [], sheetName);
     const gridData = sheetData.data?.[0];
     if (!gridData?.rowData) {
       return formatSuccessResponse(
@@ -22314,11 +22503,7 @@ async function handleGetDataValidation(input) {
     }
     const startRow = gridData.startRow ?? 0;
     const startCol = gridData.startColumn ?? 0;
-    const validationRules = compactifyValidation(
-      gridData.rowData,
-      startRow,
-      startCol
-    );
+    const validationRules = compactifyValidation(gridData.rowData, startRow, startCol);
     return formatSuccessResponse(
       { sheetName, validationRules },
       `Data validation for sheet "${sheetName}" \u2014 ${validationRules.length} unique rule(s)`
@@ -22351,22 +22536,6 @@ var getBasicFilterTool = {
     required: ["spreadsheetId", "sheetName"]
   }
 };
-function colToLetter2(col) {
-  let letter = "";
-  let c = col;
-  while (c >= 0) {
-    letter = String.fromCharCode(c % 26 + 65) + letter;
-    c = Math.floor(c / 26) - 1;
-  }
-  return letter;
-}
-function gridRangeToA13(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 `${colToLetter2(startCol)}${startRow}:${colToLetter2(endCol)}${endRow}`;
-}
 async function handleGetBasicFilter(input) {
   try {
     const { spreadsheetId, sheetName } = inputSchema9.parse(input);
@@ -22375,13 +22544,7 @@ async function handleGetBasicFilter(input) {
       spreadsheetId,
       fields: "sheets.properties.title,sheets.properties.sheetId,sheets.basicFilter"
     });
-    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 sheetData = findSheetOrThrow(response.data.sheets ?? [], sheetName);
     const bf = sheetData.basicFilter;
     if (!bf) {
       return formatSuccessResponse(
@@ -22396,7 +22559,7 @@ async function handleGetBasicFilter(input) {
         const fc = spec.filterCriteria;
         filterCriteria.push({
           columnIndex: colIdx,
-          columnLetter: colToLetter2(colIdx),
+          columnLetter: colIndexToLetter(colIdx),
           hiddenValues: fc?.hiddenValues ?? [],
           condition: fc?.condition ?? null,
           visibleBackgroundColor: fc?.visibleBackgroundColor ?? null,
@@ -22409,7 +22572,7 @@ async function handleGetBasicFilter(input) {
         const criteria = fc;
         filterCriteria.push({
           columnIndex: idx,
-          columnLetter: colToLetter2(idx),
+          columnLetter: colIndexToLetter(idx),
           hiddenValues: criteria.hiddenValues ?? [],
           condition: criteria.condition ?? null,
           visibleBackgroundColor: criteria.visibleBackgroundColor ?? null,
@@ -22417,7 +22580,7 @@ async function handleGetBasicFilter(input) {
         });
       }
     }
-    const rangeA1 = bf.range ? gridRangeToA13(bf.range) : null;
+    const rangeA1 = bf.range ? gridRangeToA1(bf.range) : null;
     return formatSuccessResponse(
       {
         sheetName,
@@ -22426,7 +22589,7 @@ async function handleGetBasicFilter(input) {
           range: rangeA1,
           sortSpecs: (bf.sortSpecs ?? []).map((s) => ({
             columnIndex: s.dimensionIndex,
-            columnLetter: s.dimensionIndex !== null && s.dimensionIndex !== void 0 ? colToLetter2(s.dimensionIndex) : null,
+            columnLetter: s.dimensionIndex !== null && s.dimensionIndex !== void 0 ? colIndexToLetter(s.dimensionIndex) : null,
             sortOrder: s.sortOrder ?? null
           })),
           filterCriteria
@@ -22439,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;
@@ -22876,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],
@@ -22885,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,
@@ -22915,6 +23422,8 @@ var allTools = [
   insertLinkTool,
   insertDateTool,
   insertRowsTool,
+  deleteColumnsTool,
+  deleteRowsTool,
   getMergedCellsTool,
   getSheetDimensionsTool,
   getSheetFormattingTool,
@@ -22923,7 +23432,9 @@ var allTools = [
   getSheetStructureTool,
   getFormattingCompactTool,
   getDataValidationTool,
-  getBasicFilterTool
+  getBasicFilterTool,
+  getBorderMapTool,
+  compareRangesTool
 ];
 async function main() {
   try {
@@ -22935,7 +23446,7 @@ async function main() {
   const server = new Server(
     {
       name: "spreadsheet",
-      version: "1.6.0"
+      version: "1.8.0"
     },
     {
       capabilities: {