gogcli-mcp-sheets 2.2.0 → 2.3.0

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
   },
   "metadata": {
     "description": "Extended Google Sheets for Claude via gogcli — auth + full Sheets support",
-    "version": "2.2.0"
+    "version": "2.3.0"
   },
   "plugins": [
     {
@@ -15,7 +15,7 @@
       "displayName": "gogcli (Sheets)",
       "source": "./",
       "description": "Extended Google Sheets for Claude via gogcli — auth + full Sheets support",
-      "version": "2.2.0",
+      "version": "2.3.0",
       "author": {
         "name": "Chris Hall"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "gogcli-mcp-sheets",
   "displayName": "gogcli (Sheets)",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Extended Google Sheets for Claude via gogcli — auth + full Sheets support",
   "author": {
     "name": "Chris Hall",

package/dist/index.js

@@ -31399,7 +31399,7 @@ function registerSheetsTools(server2) {
 }
 
 // ../gogcli-mcp/src/server.ts
-var VERSION = true ? "2.2.0" : "0.0.0";
+var VERSION = true ? "2.3.0" : "0.0.0";
 function createServer(options) {
   return new McpServer({
     name: options?.name ?? "gogcli",
@@ -31869,6 +31869,248 @@ ${result.content[0].text}` }] };
       { account }
     );
   });
+  server2.registerTool("gog_sheets_chart_list", {
+    description: "List embedded charts in a spreadsheet (chartId, type, position).",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, account }) => {
+    return runOrDiagnose(["sheets", "chart", "list", spreadsheetId], { account });
+  });
+  server2.registerTool("gog_sheets_chart_get", {
+    description: "Get the full definition (spec + position) of a single chart by its numeric chart ID.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      chartId: external_exports.string().describe("Numeric chart ID (from gog_sheets_chart_list)"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, chartId, account }) => {
+    return runOrDiagnose(["sheets", "chart", "get", spreadsheetId, chartId], { account });
+  });
+  server2.registerTool("gog_sheets_chart_create", {
+    description: "Create an embedded chart from a JSON spec. specJson is a Sheets API ChartSpec (or full EmbeddedChart) \u2014 inline or @/path/to/file.json. Anchor the chart with sheet + anchor (A1 cell), and optionally size it with width/height pixels.",
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      specJson: external_exports.string().describe("ChartSpec or EmbeddedChart JSON (inline or @file)"),
+      sheet: external_exports.string().optional().describe("Sheet name for the anchor (resolved to sheetId)"),
+      anchor: external_exports.string().optional().describe("Anchor cell in A1 notation (e.g. A1, E10)"),
+      width: external_exports.number().optional().describe("Chart width in pixels (default: 600)"),
+      height: external_exports.number().optional().describe("Chart height in pixels (default: 371)"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, specJson, sheet, anchor, width, height, account }) => {
+    const args = ["sheets", "chart", "create", spreadsheetId, `--spec-json=${specJson}`];
+    if (sheet) args.push(`--sheet=${sheet}`);
+    if (anchor) args.push(`--anchor=${anchor}`);
+    if (width !== void 0) args.push(`--width=${width}`);
+    if (height !== void 0) args.push(`--height=${height}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_sheets_chart_update", {
+    description: "Replace a chart spec by chart ID. specJson is a Sheets API ChartSpec (or full EmbeddedChart) \u2014 inline or @/path/to/file.json.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      chartId: external_exports.string().describe("Numeric chart ID to update"),
+      specJson: external_exports.string().describe("ChartSpec or EmbeddedChart JSON (inline or @file)"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, chartId, specJson, account }) => {
+    return runOrDiagnose(
+      ["sheets", "chart", "update", spreadsheetId, chartId, `--spec-json=${specJson}`],
+      { account }
+    );
+  });
+  server2.registerTool("gog_sheets_chart_delete", {
+    description: "Delete a chart by its numeric chart ID.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      chartId: external_exports.string().describe("Numeric chart ID to delete"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, chartId, account }) => {
+    return runOrDiagnose(["sheets", "chart", "delete", spreadsheetId, chartId], { account });
+  });
+  server2.registerTool("gog_sheets_table_list", {
+    description: "List Google Sheets tables in a spreadsheet (tableId, name, range).",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, account }) => {
+    return runOrDiagnose(["sheets", "table", "list", spreadsheetId], { account });
+  });
+  server2.registerTool("gog_sheets_table_get", {
+    description: "Get a single Google Sheets table (definition + columns) by its table ID.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      tableId: external_exports.string().describe("Table ID (from gog_sheets_table_list)"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, tableId, account }) => {
+    return runOrDiagnose(["sheets", "table", "get", spreadsheetId, tableId], { account });
+  });
+  server2.registerTool("gog_sheets_table_create", {
+    description: "Create a Google Sheets table over a range. columnsJson is a JSON array of column definitions (each {columnName, columnType?}); valid columnType values: TEXT, DOUBLE, BOOLEAN, DATE, DROPDOWN. Inline JSON or @/path/to/file.json.",
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      range: external_exports.string().describe("Range the table covers (e.g. Sheet1!A1:D20)"),
+      name: external_exports.string().describe("Table name"),
+      columnsJson: external_exports.string().describe("Column definitions as JSON array or @file (columnName + optional columnType)"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, range, name, columnsJson, account }) => {
+    return runOrDiagnose(
+      ["sheets", "table", "create", spreadsheetId, range, `--name=${name}`, `--columns-json=${columnsJson}`],
+      { account }
+    );
+  });
+  server2.registerTool("gog_sheets_table_append", {
+    description: "Append data rows to a table. valuesJson is a JSON 2D array of row values.",
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      tableId: external_exports.string().describe("Table ID to append to"),
+      valuesJson: external_exports.string().describe('Values as JSON 2D array (e.g. [["a",1],["b",2]])'),
+      input: external_exports.enum(["RAW", "USER_ENTERED"]).optional().describe("Value input option (default: USER_ENTERED)"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, tableId, valuesJson, input, account }) => {
+    const args = ["sheets", "table", "append", spreadsheetId, tableId, `--values-json=${valuesJson}`];
+    if (input) args.push(`--input=${input}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_sheets_table_clear", {
+    description: "Clear all data rows from a table (keeps the table and its columns).",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      tableId: external_exports.string().describe("Table ID to clear"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, tableId, account }) => {
+    return runOrDiagnose(["sheets", "table", "clear", spreadsheetId, tableId], { account });
+  });
+  server2.registerTool("gog_sheets_table_delete", {
+    description: "Delete a table by its table ID.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      tableId: external_exports.string().describe("Table ID to delete"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, tableId, account }) => {
+    return runOrDiagnose(["sheets", "table", "delete", spreadsheetId, tableId], { account });
+  });
+  server2.registerTool("gog_sheets_banding_list", {
+    description: "List alternating-color banded ranges. Optionally scope to a single sheet.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      sheet: external_exports.string().optional().describe("Only list banding from this sheet"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, sheet, account }) => {
+    const args = ["sheets", "banding", "list", spreadsheetId];
+    if (sheet) args.push(`--sheet=${sheet}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_sheets_banding_set", {
+    description: "Apply alternating colors to a range. Provide rowPropertiesJson and/or columnPropertiesJson \u2014 each a Sheets API BandingProperties JSON object ({headerColor, firstBandColor, secondBandColor, footerColor}). At least one is required.",
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      range: external_exports.string().describe("Range to band (e.g. Sheet1!A1:D20)"),
+      rowPropertiesJson: external_exports.string().optional().describe("BandingProperties JSON for row colors"),
+      columnPropertiesJson: external_exports.string().optional().describe("BandingProperties JSON for column colors"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, range, rowPropertiesJson, columnPropertiesJson, account }) => {
+    const args = ["sheets", "banding", "set", spreadsheetId, range];
+    if (rowPropertiesJson) args.push(`--row-properties-json=${rowPropertiesJson}`);
+    if (columnPropertiesJson) args.push(`--column-properties-json=${columnPropertiesJson}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_sheets_banding_clear", {
+    description: "Remove alternating-color banding. Pass id to remove a single banded range, or all:true with sheet to remove every banding on that sheet.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      id: external_exports.number().optional().describe("Banded range ID to remove"),
+      all: external_exports.boolean().optional().describe("Remove all banding from the sheet (requires sheet)"),
+      sheet: external_exports.string().optional().describe("Sheet name (used with all:true)"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, id, all, sheet, account }) => {
+    const args = ["sheets", "banding", "clear", spreadsheetId];
+    if (id !== void 0) args.push(`--id=${id}`);
+    if (all) args.push("--all");
+    if (sheet) args.push(`--sheet=${sheet}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_sheets_conditional_format_list", {
+    description: "List conditional formatting rules. Optionally scope to a single sheet.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      sheet: external_exports.string().optional().describe("Only list rules from this sheet"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, sheet, account }) => {
+    const args = ["sheets", "conditional-format", "list", spreadsheetId];
+    if (sheet) args.push(`--sheet=${sheet}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_sheets_conditional_format_add", {
+    description: "Add a conditional formatting rule to a range. type picks the condition; expr is its value/formula (omit for blank/not-blank). formatJson is the CellFormat to apply when the condition matches (inline or @file). Use formatFields to force-send zero/false fields (e.g. backgroundColor,textFormat.bold).",
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      range: external_exports.string().describe("Range the rule applies to (e.g. Sheet1!A1:A100)"),
+      type: external_exports.enum([
+        "text-eq",
+        "text-contains",
+        "text-starts-with",
+        "text-ends-with",
+        "number-eq",
+        "number-gt",
+        "number-gte",
+        "number-lt",
+        "number-lte",
+        "blank",
+        "not-blank",
+        "custom-formula"
+      ]).describe("Rule type"),
+      formatJson: external_exports.string().describe("CellFormat JSON to apply when the condition matches (inline or @file)"),
+      expr: external_exports.string().optional().describe("Expression value or custom formula (omit for blank/not-blank)"),
+      formatFields: external_exports.string().optional().describe("Format field mask for force-sending zero/false fields (e.g. backgroundColor,textFormat.bold)"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, range, type, formatJson, expr, formatFields, account }) => {
+    const args = ["sheets", "conditional-format", "add", spreadsheetId, range, `--type=${type}`, `--format-json=${formatJson}`];
+    if (expr !== void 0) args.push(`--expr=${expr}`);
+    if (formatFields) args.push(`--format-fields=${formatFields}`);
+    return runOrDiagnose(args, { account });
+  });
+  server2.registerTool("gog_sheets_conditional_format_clear", {
+    description: "Remove conditional formatting rules from a sheet. Pass index to remove a single rule by its 0-based index, or all:true to remove every rule on the sheet.",
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: external_exports.string().describe("Spreadsheet ID"),
+      sheet: external_exports.string().describe("Sheet name to clear rules from"),
+      index: external_exports.number().optional().describe("0-based rule index to remove"),
+      all: external_exports.boolean().optional().describe("Remove all conditional formatting rules from the sheet"),
+      account: accountParam
+    }
+  }, async ({ spreadsheetId, sheet, index, all, account }) => {
+    const args = ["sheets", "conditional-format", "clear", spreadsheetId, `--sheet=${sheet}`];
+    if (index !== void 0) args.push(`--index=${index}`);
+    if (all) args.push("--all");
+    return runOrDiagnose(args, { account });
+  });
 }
 
 // src/index.ts

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp-sheets",
   "display_name": "gogcli (Sheets)",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Extended Google Sheets for Claude via gogcli — auth + full Sheets support",
   "author": {
     "name": "Chris Hall",
@@ -207,6 +207,74 @@
     {
       "name": "gog_sheets_reorder_tab",
       "description": "Move a tab to a specific 0-based position."
+    },
+    {
+      "name": "gog_sheets_chart_list",
+      "description": "List embedded charts in a spreadsheet."
+    },
+    {
+      "name": "gog_sheets_chart_get",
+      "description": "Get a chart's full definition (spec + position) by chart ID."
+    },
+    {
+      "name": "gog_sheets_chart_create",
+      "description": "Create an embedded chart from a JSON ChartSpec."
+    },
+    {
+      "name": "gog_sheets_chart_update",
+      "description": "Replace a chart's spec by chart ID."
+    },
+    {
+      "name": "gog_sheets_chart_delete",
+      "description": "Delete a chart by chart ID."
+    },
+    {
+      "name": "gog_sheets_table_list",
+      "description": "List Google Sheets tables in a spreadsheet."
+    },
+    {
+      "name": "gog_sheets_table_get",
+      "description": "Get a Google Sheets table by table ID."
+    },
+    {
+      "name": "gog_sheets_table_create",
+      "description": "Create a Google Sheets table over a range with typed columns."
+    },
+    {
+      "name": "gog_sheets_table_append",
+      "description": "Append data rows to a table."
+    },
+    {
+      "name": "gog_sheets_table_clear",
+      "description": "Clear all data rows from a table."
+    },
+    {
+      "name": "gog_sheets_table_delete",
+      "description": "Delete a table by table ID."
+    },
+    {
+      "name": "gog_sheets_banding_list",
+      "description": "List alternating-color banded ranges."
+    },
+    {
+      "name": "gog_sheets_banding_set",
+      "description": "Apply alternating colors to a range."
+    },
+    {
+      "name": "gog_sheets_banding_clear",
+      "description": "Remove alternating-color banding by ID or for a whole sheet."
+    },
+    {
+      "name": "gog_sheets_conditional_format_list",
+      "description": "List conditional formatting rules."
+    },
+    {
+      "name": "gog_sheets_conditional_format_add",
+      "description": "Add a conditional formatting rule to a range."
+    },
+    {
+      "name": "gog_sheets_conditional_format_clear",
+      "description": "Remove conditional formatting rules from a sheet."
     }
   ],
   "compatibility": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gogcli-mcp-sheets",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "mcpName": "io.github.chrischall/gogcli-mcp-sheets",
   "description": "Extended Google Sheets MCP server via gogcli — all base tools plus full Sheets support",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",

package/server.json

@@ -7,12 +7,12 @@
     "source": "github",
     "subfolder": "packages/gogcli-mcp-sheets"
   },
-  "version": "2.2.0",
+  "version": "2.3.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "gogcli-mcp-sheets",
-      "version": "2.2.0",
+      "version": "2.3.0",
       "transport": {
         "type": "stdio"
       },

package/src/tools/sheets-extra.ts

@@ -520,4 +520,262 @@ export function registerExtraSheetsTools(server: McpServer): void {
       { account },
     );
   });
+
+  // ---- Charts (gog 0.19.0) ----
+
+  server.registerTool('gog_sheets_chart_list', {
+    description: 'List embedded charts in a spreadsheet (chartId, type, position).',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, account }) => {
+    return runOrDiagnose(['sheets', 'chart', 'list', spreadsheetId], { account });
+  });
+
+  server.registerTool('gog_sheets_chart_get', {
+    description: 'Get the full definition (spec + position) of a single chart by its numeric chart ID.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      chartId: z.string().describe('Numeric chart ID (from gog_sheets_chart_list)'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, chartId, account }) => {
+    return runOrDiagnose(['sheets', 'chart', 'get', spreadsheetId, chartId], { account });
+  });
+
+  server.registerTool('gog_sheets_chart_create', {
+    description: 'Create an embedded chart from a JSON spec. specJson is a Sheets API ChartSpec (or full EmbeddedChart) — inline or @/path/to/file.json. Anchor the chart with sheet + anchor (A1 cell), and optionally size it with width/height pixels.',
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      specJson: z.string().describe('ChartSpec or EmbeddedChart JSON (inline or @file)'),
+      sheet: z.string().optional().describe('Sheet name for the anchor (resolved to sheetId)'),
+      anchor: z.string().optional().describe('Anchor cell in A1 notation (e.g. A1, E10)'),
+      width: z.number().optional().describe('Chart width in pixels (default: 600)'),
+      height: z.number().optional().describe('Chart height in pixels (default: 371)'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, specJson, sheet, anchor, width, height, account }) => {
+    const args = ['sheets', 'chart', 'create', spreadsheetId, `--spec-json=${specJson}`];
+    if (sheet) args.push(`--sheet=${sheet}`);
+    if (anchor) args.push(`--anchor=${anchor}`);
+    if (width !== undefined) args.push(`--width=${width}`);
+    if (height !== undefined) args.push(`--height=${height}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_sheets_chart_update', {
+    description: 'Replace a chart spec by chart ID. specJson is a Sheets API ChartSpec (or full EmbeddedChart) — inline or @/path/to/file.json.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      chartId: z.string().describe('Numeric chart ID to update'),
+      specJson: z.string().describe('ChartSpec or EmbeddedChart JSON (inline or @file)'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, chartId, specJson, account }) => {
+    return runOrDiagnose(
+      ['sheets', 'chart', 'update', spreadsheetId, chartId, `--spec-json=${specJson}`],
+      { account },
+    );
+  });
+
+  server.registerTool('gog_sheets_chart_delete', {
+    description: 'Delete a chart by its numeric chart ID.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      chartId: z.string().describe('Numeric chart ID to delete'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, chartId, account }) => {
+    return runOrDiagnose(['sheets', 'chart', 'delete', spreadsheetId, chartId], { account });
+  });
+
+  // ---- Tables (gog 0.19.0) ----
+
+  server.registerTool('gog_sheets_table_list', {
+    description: 'List Google Sheets tables in a spreadsheet (tableId, name, range).',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, account }) => {
+    return runOrDiagnose(['sheets', 'table', 'list', spreadsheetId], { account });
+  });
+
+  server.registerTool('gog_sheets_table_get', {
+    description: 'Get a single Google Sheets table (definition + columns) by its table ID.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      tableId: z.string().describe('Table ID (from gog_sheets_table_list)'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, tableId, account }) => {
+    return runOrDiagnose(['sheets', 'table', 'get', spreadsheetId, tableId], { account });
+  });
+
+  server.registerTool('gog_sheets_table_create', {
+    description: 'Create a Google Sheets table over a range. columnsJson is a JSON array of column definitions (each {columnName, columnType?}); valid columnType values: TEXT, DOUBLE, BOOLEAN, DATE, DROPDOWN. Inline JSON or @/path/to/file.json.',
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      range: z.string().describe('Range the table covers (e.g. Sheet1!A1:D20)'),
+      name: z.string().describe('Table name'),
+      columnsJson: z.string().describe('Column definitions as JSON array or @file (columnName + optional columnType)'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, range, name, columnsJson, account }) => {
+    return runOrDiagnose(
+      ['sheets', 'table', 'create', spreadsheetId, range, `--name=${name}`, `--columns-json=${columnsJson}`],
+      { account },
+    );
+  });
+
+  server.registerTool('gog_sheets_table_append', {
+    description: 'Append data rows to a table. valuesJson is a JSON 2D array of row values.',
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      tableId: z.string().describe('Table ID to append to'),
+      valuesJson: z.string().describe('Values as JSON 2D array (e.g. [["a",1],["b",2]])'),
+      input: z.enum(['RAW', 'USER_ENTERED']).optional().describe('Value input option (default: USER_ENTERED)'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, tableId, valuesJson, input, account }) => {
+    const args = ['sheets', 'table', 'append', spreadsheetId, tableId, `--values-json=${valuesJson}`];
+    if (input) args.push(`--input=${input}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_sheets_table_clear', {
+    description: 'Clear all data rows from a table (keeps the table and its columns).',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      tableId: z.string().describe('Table ID to clear'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, tableId, account }) => {
+    return runOrDiagnose(['sheets', 'table', 'clear', spreadsheetId, tableId], { account });
+  });
+
+  server.registerTool('gog_sheets_table_delete', {
+    description: 'Delete a table by its table ID.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      tableId: z.string().describe('Table ID to delete'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, tableId, account }) => {
+    return runOrDiagnose(['sheets', 'table', 'delete', spreadsheetId, tableId], { account });
+  });
+
+  // ---- Banding / alternating colors (gog 0.19.0) ----
+
+  server.registerTool('gog_sheets_banding_list', {
+    description: 'List alternating-color banded ranges. Optionally scope to a single sheet.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      sheet: z.string().optional().describe('Only list banding from this sheet'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, sheet, account }) => {
+    const args = ['sheets', 'banding', 'list', spreadsheetId];
+    if (sheet) args.push(`--sheet=${sheet}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_sheets_banding_set', {
+    description: 'Apply alternating colors to a range. Provide rowPropertiesJson and/or columnPropertiesJson — each a Sheets API BandingProperties JSON object ({headerColor, firstBandColor, secondBandColor, footerColor}). At least one is required.',
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      range: z.string().describe('Range to band (e.g. Sheet1!A1:D20)'),
+      rowPropertiesJson: z.string().optional().describe('BandingProperties JSON for row colors'),
+      columnPropertiesJson: z.string().optional().describe('BandingProperties JSON for column colors'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, range, rowPropertiesJson, columnPropertiesJson, account }) => {
+    const args = ['sheets', 'banding', 'set', spreadsheetId, range];
+    if (rowPropertiesJson) args.push(`--row-properties-json=${rowPropertiesJson}`);
+    if (columnPropertiesJson) args.push(`--column-properties-json=${columnPropertiesJson}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_sheets_banding_clear', {
+    description: 'Remove alternating-color banding. Pass id to remove a single banded range, or all:true with sheet to remove every banding on that sheet.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      id: z.number().optional().describe('Banded range ID to remove'),
+      all: z.boolean().optional().describe('Remove all banding from the sheet (requires sheet)'),
+      sheet: z.string().optional().describe('Sheet name (used with all:true)'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, id, all, sheet, account }) => {
+    const args = ['sheets', 'banding', 'clear', spreadsheetId];
+    if (id !== undefined) args.push(`--id=${id}`);
+    if (all) args.push('--all');
+    if (sheet) args.push(`--sheet=${sheet}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  // ---- Conditional formatting (gog 0.19.0) ----
+
+  server.registerTool('gog_sheets_conditional_format_list', {
+    description: 'List conditional formatting rules. Optionally scope to a single sheet.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      sheet: z.string().optional().describe('Only list rules from this sheet'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, sheet, account }) => {
+    const args = ['sheets', 'conditional-format', 'list', spreadsheetId];
+    if (sheet) args.push(`--sheet=${sheet}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_sheets_conditional_format_add', {
+    description: 'Add a conditional formatting rule to a range. type picks the condition; expr is its value/formula (omit for blank/not-blank). formatJson is the CellFormat to apply when the condition matches (inline or @file). Use formatFields to force-send zero/false fields (e.g. backgroundColor,textFormat.bold).',
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      range: z.string().describe('Range the rule applies to (e.g. Sheet1!A1:A100)'),
+      type: z.enum([
+        'text-eq', 'text-contains', 'text-starts-with', 'text-ends-with',
+        'number-eq', 'number-gt', 'number-gte', 'number-lt', 'number-lte',
+        'blank', 'not-blank', 'custom-formula',
+      ]).describe('Rule type'),
+      formatJson: z.string().describe('CellFormat JSON to apply when the condition matches (inline or @file)'),
+      expr: z.string().optional().describe('Expression value or custom formula (omit for blank/not-blank)'),
+      formatFields: z.string().optional().describe('Format field mask for force-sending zero/false fields (e.g. backgroundColor,textFormat.bold)'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, range, type, formatJson, expr, formatFields, account }) => {
+    const args = ['sheets', 'conditional-format', 'add', spreadsheetId, range, `--type=${type}`, `--format-json=${formatJson}`];
+    if (expr !== undefined) args.push(`--expr=${expr}`);
+    if (formatFields) args.push(`--format-fields=${formatFields}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  server.registerTool('gog_sheets_conditional_format_clear', {
+    description: 'Remove conditional formatting rules from a sheet. Pass index to remove a single rule by its 0-based index, or all:true to remove every rule on the sheet.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      sheet: z.string().describe('Sheet name to clear rules from'),
+      index: z.number().optional().describe('0-based rule index to remove'),
+      all: z.boolean().optional().describe('Remove all conditional formatting rules from the sheet'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, sheet, index, all, account }) => {
+    const args = ['sheets', 'conditional-format', 'clear', spreadsheetId, `--sheet=${sheet}`];
+    if (index !== undefined) args.push(`--index=${index}`);
+    if (all) args.push('--all');
+    return runOrDiagnose(args, { account });
+  });
 }

package/tests/tools/sheets-extra.test.ts

@@ -487,6 +487,18 @@ describe('gog_sheets_number_format', () => {
       expect(result.content[0].text).toMatch(/warning/i);
     });
 
+    it('does not warn when every cell is null or empty (no small integers seen)', async () => {
+      const handlers = setupHandlers();
+      vi.mocked(lib.runOrDiagnose).mockImplementation(async (args: string[]) => {
+        if (args[1] === 'get') {
+          return toText(JSON.stringify({ range: 'A1:A3', values: [[null], [''], [null]] }));
+        }
+        return toText('{"ok":true}');
+      });
+      const result = await handlers.get('gog_sheets_number_format')!({ spreadsheetId: 'sid', range: 'A1:A3', type: 'DATE' });
+      expect(result.content[0].text).not.toMatch(/warning/i);
+    });
+
     it('proceeds with format when peek fails (does not block)', async () => {
       const handlers = setupHandlers();
       vi.mocked(lib.runOrDiagnose).mockImplementation(async (args: string[]) => {
@@ -775,3 +787,325 @@ describe('gog_sheets_reorder_tab', () => {
     );
   });
 });
+
+// 25. chart list (gog 0.19.0)
+describe('gog_sheets_chart_list', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_chart_list')!({ spreadsheetId: 'sid' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'chart', 'list', 'sid'], { account: undefined });
+  });
+
+  it('forwards account', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_chart_list')!({ spreadsheetId: 'sid', account: 'a@b.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'chart', 'list', 'sid'], { account: 'a@b.com' });
+  });
+});
+
+// 26. chart get
+describe('gog_sheets_chart_get', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_chart_get')!({ spreadsheetId: 'sid', chartId: '12345' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'chart', 'get', 'sid', '12345'], { account: undefined });
+  });
+});
+
+// 27. chart create
+describe('gog_sheets_chart_create', () => {
+  it('calls runOrDiagnose with only --spec-json', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    const spec = '{"basicChart":{"chartType":"COLUMN"}}';
+    await handlers.get('gog_sheets_chart_create')!({ spreadsheetId: 'sid', specJson: spec });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['sheets', 'chart', 'create', 'sid', `--spec-json=${spec}`],
+      { account: undefined },
+    );
+  });
+
+  it('includes --sheet, --anchor, --width, --height when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_chart_create')!({
+      spreadsheetId: 'sid', specJson: '{}', sheet: 'Data', anchor: 'E10', width: 800, height: 400,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['sheets', 'chart', 'create', 'sid', '--spec-json={}', '--sheet=Data', '--anchor=E10', '--width=800', '--height=400'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --width=0 and --height=0 when zero', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_chart_create')!({ spreadsheetId: 'sid', specJson: '{}', width: 0, height: 0 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['sheets', 'chart', 'create', 'sid', '--spec-json={}', '--width=0', '--height=0'],
+      { account: undefined },
+    );
+  });
+});
+
+// 28. chart update
+describe('gog_sheets_chart_update', () => {
+  it('calls runOrDiagnose with chartId and --spec-json', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_chart_update')!({ spreadsheetId: 'sid', chartId: '99', specJson: '{}' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['sheets', 'chart', 'update', 'sid', '99', '--spec-json={}'],
+      { account: undefined },
+    );
+  });
+});
+
+// 29. chart delete
+describe('gog_sheets_chart_delete', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_chart_delete')!({ spreadsheetId: 'sid', chartId: '7' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'chart', 'delete', 'sid', '7'], { account: undefined });
+  });
+});
+
+// 30. table list
+describe('gog_sheets_table_list', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_table_list')!({ spreadsheetId: 'sid' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'table', 'list', 'sid'], { account: undefined });
+  });
+});
+
+// 31. table get
+describe('gog_sheets_table_get', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_table_get')!({ spreadsheetId: 'sid', tableId: 't1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'table', 'get', 'sid', 't1'], { account: undefined });
+  });
+});
+
+// 32. table create
+describe('gog_sheets_table_create', () => {
+  it('calls runOrDiagnose with range, --name, --columns-json', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    const cols = '[{"columnName":"Name","columnType":"TEXT"}]';
+    await handlers.get('gog_sheets_table_create')!({ spreadsheetId: 'sid', range: 'Sheet1!A1:B10', name: 'People', columnsJson: cols });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['sheets', 'table', 'create', 'sid', 'Sheet1!A1:B10', '--name=People', `--columns-json=${cols}`],
+      { account: undefined },
+    );
+  });
+});
+
+// 33. table append
+describe('gog_sheets_table_append', () => {
+  it('calls runOrDiagnose with --values-json (no --input)', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_table_append')!({ spreadsheetId: 'sid', tableId: 't1', valuesJson: '[["a",1]]' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['sheets', 'table', 'append', 'sid', 't1', '--values-json=[["a",1]]'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --input when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_table_append')!({ spreadsheetId: 'sid', tableId: 't1', valuesJson: '[]', input: 'RAW' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['sheets', 'table', 'append', 'sid', 't1', '--values-json=[]', '--input=RAW'],
+      { account: undefined },
+    );
+  });
+});
+
+// 34. table clear
+describe('gog_sheets_table_clear', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_table_clear')!({ spreadsheetId: 'sid', tableId: 't1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'table', 'clear', 'sid', 't1'], { account: undefined });
+  });
+});
+
+// 35. table delete
+describe('gog_sheets_table_delete', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_table_delete')!({ spreadsheetId: 'sid', tableId: 't1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'table', 'delete', 'sid', 't1'], { account: undefined });
+  });
+});
+
+// 36. banding list
+describe('gog_sheets_banding_list', () => {
+  it('calls runOrDiagnose with no --sheet', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_banding_list')!({ spreadsheetId: 'sid' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'banding', 'list', 'sid'], { account: undefined });
+  });
+
+  it('includes --sheet when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_banding_list')!({ spreadsheetId: 'sid', sheet: 'Data' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'banding', 'list', 'sid', '--sheet=Data'], { account: undefined });
+  });
+});
+
+// 37. banding set
+describe('gog_sheets_banding_set', () => {
+  it('calls runOrDiagnose with range only', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_banding_set')!({ spreadsheetId: 'sid', range: 'Sheet1!A1:D20' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'banding', 'set', 'sid', 'Sheet1!A1:D20'], { account: undefined });
+  });
+
+  it('includes --row-properties-json and --column-properties-json when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_banding_set')!({
+      spreadsheetId: 'sid', range: 'A1:D20',
+      rowPropertiesJson: '{"firstBandColor":{}}',
+      columnPropertiesJson: '{"secondBandColor":{}}',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['sheets', 'banding', 'set', 'sid', 'A1:D20', '--row-properties-json={"firstBandColor":{}}', '--column-properties-json={"secondBandColor":{}}'],
+      { account: undefined },
+    );
+  });
+});
+
+// 38. banding clear
+describe('gog_sheets_banding_clear', () => {
+  it('calls runOrDiagnose with no optional flags', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_banding_clear')!({ spreadsheetId: 'sid' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'banding', 'clear', 'sid'], { account: undefined });
+  });
+
+  it('includes --id when provided (including 0)', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_banding_clear')!({ spreadsheetId: 'sid', id: 0 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'banding', 'clear', 'sid', '--id=0'], { account: undefined });
+  });
+
+  it('includes --all and --sheet when clearing a whole sheet', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_banding_clear')!({ spreadsheetId: 'sid', all: true, sheet: 'Data' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'banding', 'clear', 'sid', '--all', '--sheet=Data'], { account: undefined });
+  });
+
+  it('omits --all when false', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_banding_clear')!({ spreadsheetId: 'sid', all: false, id: 5 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'banding', 'clear', 'sid', '--id=5'], { account: undefined });
+  });
+});
+
+// 39. conditional-format list
+describe('gog_sheets_conditional_format_list', () => {
+  it('calls runOrDiagnose with no --sheet', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_conditional_format_list')!({ spreadsheetId: 'sid' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'conditional-format', 'list', 'sid'], { account: undefined });
+  });
+
+  it('includes --sheet when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_conditional_format_list')!({ spreadsheetId: 'sid', sheet: 'Data' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'conditional-format', 'list', 'sid', '--sheet=Data'], { account: undefined });
+  });
+});
+
+// 40. conditional-format add
+describe('gog_sheets_conditional_format_add', () => {
+  it('calls runOrDiagnose with type and --format-json (no expr/fields)', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_conditional_format_add')!({
+      spreadsheetId: 'sid', range: 'A1:A100', type: 'not-blank', formatJson: '{"backgroundColor":{}}',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['sheets', 'conditional-format', 'add', 'sid', 'A1:A100', '--type=not-blank', '--format-json={"backgroundColor":{}}'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --expr and --format-fields when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_conditional_format_add')!({
+      spreadsheetId: 'sid', range: 'B1:B50', type: 'number-gt', expr: '100', formatJson: '{}', formatFields: 'backgroundColor,textFormat.bold',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['sheets', 'conditional-format', 'add', 'sid', 'B1:B50', '--type=number-gt', '--format-json={}', '--expr=100', '--format-fields=backgroundColor,textFormat.bold'],
+      { account: undefined },
+    );
+  });
+
+  it('includes --expr when it is an empty string', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_conditional_format_add')!({
+      spreadsheetId: 'sid', range: 'A1', type: 'text-eq', expr: '', formatJson: '{}',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['sheets', 'conditional-format', 'add', 'sid', 'A1', '--type=text-eq', '--format-json={}', '--expr='],
+      { account: undefined },
+    );
+  });
+});
+
+// 41. conditional-format clear
+describe('gog_sheets_conditional_format_clear', () => {
+  it('calls runOrDiagnose with --sheet only', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_conditional_format_clear')!({ spreadsheetId: 'sid', sheet: 'Data' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'conditional-format', 'clear', 'sid', '--sheet=Data'], { account: undefined });
+  });
+
+  it('includes --index when provided (including 0)', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_conditional_format_clear')!({ spreadsheetId: 'sid', sheet: 'Data', index: 0 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'conditional-format', 'clear', 'sid', '--sheet=Data', '--index=0'], { account: undefined });
+  });
+
+  it('includes --all when true', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_conditional_format_clear')!({ spreadsheetId: 'sid', sheet: 'Data', all: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'conditional-format', 'clear', 'sid', '--sheet=Data', '--all'], { account: undefined });
+  });
+
+  it('omits --all when false', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_conditional_format_clear')!({ spreadsheetId: 'sid', sheet: 'Data', all: false, index: 2 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'conditional-format', 'clear', 'sid', '--sheet=Data', '--index=2'], { account: undefined });
+  });
+});