gogcli-mcp-sheets 1.0.6

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "gogcli-mcp-sheets",
+  "version": "1.0.6",
+  "description": "Extended Google Sheets MCP server via gogcli — all base tools plus full Sheets support",
+  "type": "module",
+  "bin": {
+    "gogcli-mcp-sheets": "dist/index.js"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc --noEmit && npm run bundle",
+    "bundle": "node ../../scripts/bundle.js src/index.ts dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "gogcli-mcp": "*",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.3.6"
+  },
+  "license": "MIT"
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createBaseServer } from 'gogcli-mcp/lib';
+import { registerExtraSheetsTools } from './tools/sheets-extra.js';
+
+const server = createBaseServer({ name: 'gogcli-sheets' });
+registerExtraSheetsTools(server);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/src/tools/sheets-extra.ts

@@ -0,0 +1,340 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { accountParam, runOrDiagnose } from 'gogcli-mcp/lib';
+
+export function registerExtraSheetsTools(server: McpServer): void {
+  // 1. Add tab
+  server.registerTool('gog_sheets_add_tab', {
+    description: 'Add a new sheet tab to a spreadsheet.',
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID (from the URL)'),
+      tabName: z.string().describe('Name for the new tab'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, tabName, account }) => {
+    return runOrDiagnose(['sheets', 'add-tab', spreadsheetId, tabName], { account });
+  });
+
+  // 2. Delete tab
+  server.registerTool('gog_sheets_delete_tab', {
+    description: 'Delete a sheet tab from a spreadsheet.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      tabName: z.string().describe('Name of the tab to delete'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, tabName, account }) => {
+    return runOrDiagnose(['sheets', 'delete-tab', spreadsheetId, tabName], { account });
+  });
+
+  // 3. Rename tab
+  server.registerTool('gog_sheets_rename_tab', {
+    description: 'Rename a sheet tab.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      oldName: z.string().describe('Current tab name'),
+      newName: z.string().describe('New tab name'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, oldName, newName, account }) => {
+    return runOrDiagnose(['sheets', 'rename-tab', spreadsheetId, oldName, newName], { account });
+  });
+
+  // 4. Copy spreadsheet
+  server.registerTool('gog_sheets_copy', {
+    description: 'Copy a spreadsheet to a new spreadsheet with the given title.',
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID to copy'),
+      title: z.string().describe('Title for the new copy'),
+      parent: z.string().optional().describe('Parent folder ID to place the copy in'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, title, parent, account }) => {
+    const args = ['sheets', 'copy', spreadsheetId, title];
+    if (parent) args.push(`--parent=${parent}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  // 5. Export spreadsheet
+  server.registerTool('gog_sheets_export', {
+    description: 'Export a spreadsheet as CSV, TSV, or PDF.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      format: z.string().optional().describe('Export format: csv, tsv, pdf (default: csv)'),
+      out: z.string().optional().describe('Output file path'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, format, out, account }) => {
+    const args = ['sheets', 'export', spreadsheetId];
+    if (format) args.push(`--format=${format}`);
+    if (out) args.push(`--out=${out}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  // 6. Freeze rows/columns
+  server.registerTool('gog_sheets_freeze', {
+    description: 'Freeze rows and/or columns in a sheet.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      rows: z.number().optional().describe('Number of rows to freeze'),
+      cols: z.number().optional().describe('Number of columns to freeze'),
+      sheet: z.string().optional().describe('Sheet tab name (default: first sheet)'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, rows, cols, sheet, account }) => {
+    const args = ['sheets', 'freeze', spreadsheetId];
+    if (rows !== undefined) args.push(`--rows=${rows}`);
+    if (cols !== undefined) args.push(`--cols=${cols}`);
+    if (sheet) args.push(`--sheet=${sheet}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  // 7. Insert rows/columns
+  server.registerTool('gog_sheets_insert', {
+    description: 'Insert rows or columns into a sheet.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      sheet: z.string().describe('Sheet tab name'),
+      dimension: z.string().describe('Dimension to insert: ROWS or COLUMNS'),
+      start: z.number().describe('Start index (0-based)'),
+      count: z.number().optional().describe('Number of rows/columns to insert (default: 1)'),
+      after: z.boolean().optional().describe('Insert after the start index instead of before'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, sheet, dimension, start, count, after, account }) => {
+    const args = ['sheets', 'insert', spreadsheetId, sheet, dimension, String(start)];
+    if (count !== undefined) args.push(`--count=${count}`);
+    if (after) args.push('--after');
+    return runOrDiagnose(args, { account });
+  });
+
+  // 8. Merge cells
+  server.registerTool('gog_sheets_merge', {
+    description: 'Merge cells in a range.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      range: z.string().describe('Range to merge (e.g. Sheet1!A1:C3)'),
+      type: z.string().optional().describe('Merge type: MERGE_ALL, MERGE_COLUMNS, MERGE_ROWS'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, range, type, account }) => {
+    const args = ['sheets', 'merge', spreadsheetId, range];
+    if (type) args.push(`--type=${type}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  // 9. Unmerge cells
+  server.registerTool('gog_sheets_unmerge', {
+    description: 'Unmerge previously merged cells in a range.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      range: z.string().describe('Range to unmerge (e.g. Sheet1!A1:C3)'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, range, account }) => {
+    return runOrDiagnose(['sheets', 'unmerge', spreadsheetId, range], { account });
+  });
+
+  // 10. Format cells
+  server.registerTool('gog_sheets_format', {
+    description: 'Apply cell formatting (bold, colors, alignment, etc.) to a range. Pass format as a JSON CellFormat object.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      range: z.string().describe('Range to format (e.g. Sheet1!A1:C3)'),
+      formatJson: z.string().describe('JSON CellFormat object (e.g. {"textFormat":{"bold":true}})'),
+      formatFields: z.string().optional().describe('Comma-separated field mask (e.g. textFormat.bold,backgroundColor)'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, range, formatJson, formatFields, account }) => {
+    const args = ['sheets', 'format', spreadsheetId, range, `--format-json=${formatJson}`];
+    if (formatFields) args.push(`--format-fields=${formatFields}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  // 11. Number format
+  server.registerTool('gog_sheets_number_format', {
+    description: 'Set number format on a range (currency, percentage, date, etc.).',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      range: z.string().describe('Range to format (e.g. Sheet1!A1:A10)'),
+      type: z.string().optional().describe('Format type: NUMBER, CURRENCY, PERCENT, DATE, TIME, SCIENTIFIC, etc.'),
+      pattern: z.string().optional().describe('Custom format pattern (e.g. "#,##0.00", "yyyy-mm-dd")'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, range, type, pattern, account }) => {
+    const args = ['sheets', 'number-format', spreadsheetId, range];
+    if (type) args.push(`--type=${type}`);
+    if (pattern) args.push(`--pattern=${pattern}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  // 12. Read format
+  server.registerTool('gog_sheets_read_format', {
+    description: 'Read cell formatting for a range.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      range: z.string().describe('Range to read formatting from'),
+      effective: z.boolean().optional().describe('Return effective (computed) format including inherited styles'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, range, effective, account }) => {
+    const args = ['sheets', 'read-format', spreadsheetId, range];
+    if (effective) args.push('--effective');
+    return runOrDiagnose(args, { account });
+  });
+
+  // 13. Resize columns
+  server.registerTool('gog_sheets_resize_columns', {
+    description: 'Resize column widths. Use --auto for auto-fit or --width for a specific pixel width.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      columns: z.string().describe('Column range (e.g. A:C, or Sheet1!A:C)'),
+      width: z.number().optional().describe('Width in pixels'),
+      auto: z.boolean().optional().describe('Auto-fit column width to content'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, columns, width, auto, account }) => {
+    const args = ['sheets', 'resize-columns', spreadsheetId, columns];
+    if (width !== undefined) args.push(`--width=${width}`);
+    if (auto) args.push('--auto');
+    return runOrDiagnose(args, { account });
+  });
+
+  // 14. Resize rows
+  server.registerTool('gog_sheets_resize_rows', {
+    description: 'Resize row heights. Use --auto for auto-fit or --height for a specific pixel height.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      rows: z.string().describe('Row range (e.g. 1:10, or Sheet1!1:10)'),
+      height: z.number().optional().describe('Height in pixels'),
+      auto: z.boolean().optional().describe('Auto-fit row height to content'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, rows, height, auto, account }) => {
+    const args = ['sheets', 'resize-rows', spreadsheetId, rows];
+    if (height !== undefined) args.push(`--height=${height}`);
+    if (auto) args.push('--auto');
+    return runOrDiagnose(args, { account });
+  });
+
+  // 15. Notes (read)
+  server.registerTool('gog_sheets_notes', {
+    description: 'Read cell notes in a range.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      range: z.string().describe('Range to read notes from (e.g. Sheet1!A1:B5)'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, range, account }) => {
+    return runOrDiagnose(['sheets', 'notes', spreadsheetId, range], { account });
+  });
+
+  // 16. Update note
+  server.registerTool('gog_sheets_update_note', {
+    description: 'Add, update, or clear a cell note. Pass an empty string to clear the note.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      range: z.string().describe('Cell or range to set the note on (e.g. Sheet1!A1)'),
+      note: z.string().describe('Note text (empty string clears the note)'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, range, note, account }) => {
+    return runOrDiagnose(['sheets', 'update-note', spreadsheetId, range, `--note=${note}`], { account });
+  });
+
+  // 17. Links
+  server.registerTool('gog_sheets_links', {
+    description: 'List hyperlinks in a range.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      range: z.string().describe('Range to scan for hyperlinks (e.g. Sheet1!A1:Z100)'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, range, account }) => {
+    return runOrDiagnose(['sheets', 'links', spreadsheetId, range], { account });
+  });
+
+  // 18. Named ranges list
+  server.registerTool('gog_sheets_named_ranges_list', {
+    description: 'List all named ranges in a spreadsheet.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, account }) => {
+    return runOrDiagnose(['sheets', 'named-ranges', 'list', spreadsheetId], { account });
+  });
+
+  // 19. Named ranges get
+  server.registerTool('gog_sheets_named_ranges_get', {
+    description: 'Get a named range by name or ID.',
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      nameOrId: z.string().describe('Named range name or ID'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, nameOrId, account }) => {
+    return runOrDiagnose(['sheets', 'named-ranges', 'get', spreadsheetId, nameOrId], { account });
+  });
+
+  // 20. Named ranges add
+  server.registerTool('gog_sheets_named_ranges_add', {
+    description: 'Create a new named range.',
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      name: z.string().describe('Name for the range'),
+      range: z.string().describe('Cell range (e.g. Sheet1!A1:B10)'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, name, range, account }) => {
+    return runOrDiagnose(['sheets', 'named-ranges', 'add', spreadsheetId, name, range], { account });
+  });
+
+  // 21. Named ranges update
+  server.registerTool('gog_sheets_named_ranges_update', {
+    description: 'Update a named range (change its name, range, or both).',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      nameOrId: z.string().describe('Current named range name or ID'),
+      name: z.string().optional().describe('New name'),
+      range: z.string().optional().describe('New cell range'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, nameOrId, name, range, account }) => {
+    const args = ['sheets', 'named-ranges', 'update', spreadsheetId, nameOrId];
+    if (name) args.push(`--name=${name}`);
+    if (range) args.push(`--range=${range}`);
+    return runOrDiagnose(args, { account });
+  });
+
+  // 22. Named ranges delete
+  server.registerTool('gog_sheets_named_ranges_delete', {
+    description: 'Delete a named range.',
+    annotations: { destructiveHint: true },
+    inputSchema: {
+      spreadsheetId: z.string().describe('Spreadsheet ID'),
+      nameOrId: z.string().describe('Named range name or ID to delete'),
+      account: accountParam,
+    },
+  }, async ({ spreadsheetId, nameOrId, account }) => {
+    return runOrDiagnose(['sheets', 'named-ranges', 'delete', spreadsheetId, nameOrId], { account });
+  });
+}

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

@@ -0,0 +1,385 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerExtraSheetsTools } from '../../src/tools/sheets-extra.js';
+import * as lib from 'gogcli-mcp/lib';
+
+vi.mock('gogcli-mcp/lib', async (importOriginal) => {
+  const actual = await importOriginal<typeof lib>();
+  return {
+    ...actual,
+    runOrDiagnose: vi.fn(),
+  };
+});
+
+type ToolHandler = (args: Record<string, unknown>) => Promise<{ content: Array<{ type: string; text: string }> }>;
+
+function toText(text: string) {
+  return { content: [{ type: 'text', text }] };
+}
+
+function setupHandlers(): Map<string, ToolHandler> {
+  const server = new McpServer({ name: 'test', version: '0.0.0' });
+  const handlers = new Map<string, ToolHandler>();
+  vi.spyOn(server, 'registerTool').mockImplementation((name, _config, cb) => {
+    handlers.set(name, cb as ToolHandler);
+    return undefined as never;
+  });
+  registerExtraSheetsTools(server);
+  return handlers;
+}
+
+beforeEach(() => vi.clearAllMocks());
+
+// 1. add-tab
+describe('gog_sheets_add_tab', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_add_tab')!({ spreadsheetId: 'sid', tabName: 'NewTab' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'add-tab', 'sid', 'NewTab'], { account: undefined });
+  });
+
+  it('forwards account', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_add_tab')!({ spreadsheetId: 'sid', tabName: 'T', account: 'a@b.com' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'add-tab', 'sid', 'T'], { account: 'a@b.com' });
+  });
+});
+
+// 2. delete-tab
+describe('gog_sheets_delete_tab', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_delete_tab')!({ spreadsheetId: 'sid', tabName: 'OldTab' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'delete-tab', 'sid', 'OldTab'], { account: undefined });
+  });
+});
+
+// 3. rename-tab
+describe('gog_sheets_rename_tab', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_rename_tab')!({ spreadsheetId: 'sid', oldName: 'Old', newName: 'New' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'rename-tab', 'sid', 'Old', 'New'], { account: undefined });
+  });
+});
+
+// 4. copy
+describe('gog_sheets_copy', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_copy')!({ spreadsheetId: 'sid', title: 'Copy' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'copy', 'sid', 'Copy'], { account: undefined });
+  });
+
+  it('includes --parent when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_copy')!({ spreadsheetId: 'sid', title: 'Copy', parent: 'folderId' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'copy', 'sid', 'Copy', '--parent=folderId'], { account: undefined });
+  });
+});
+
+// 5. export
+describe('gog_sheets_export', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_export')!({ spreadsheetId: 'sid' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'export', 'sid'], { account: undefined });
+  });
+
+  it('includes --format and --out when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_export')!({ spreadsheetId: 'sid', format: 'pdf', out: '/tmp/out.pdf' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'export', 'sid', '--format=pdf', '--out=/tmp/out.pdf'], { account: undefined });
+  });
+});
+
+// 6. freeze
+describe('gog_sheets_freeze', () => {
+  it('calls runOrDiagnose with no optional flags', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_freeze')!({ spreadsheetId: 'sid' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'freeze', 'sid'], { account: undefined });
+  });
+
+  it('includes --rows, --cols, --sheet when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_freeze')!({ spreadsheetId: 'sid', rows: 1, cols: 2, sheet: 'Data' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'freeze', 'sid', '--rows=1', '--cols=2', '--sheet=Data'], { account: undefined });
+  });
+
+  it('includes --rows=0 when rows is 0', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_freeze')!({ spreadsheetId: 'sid', rows: 0 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'freeze', 'sid', '--rows=0'], { account: undefined });
+  });
+});
+
+// 7. insert
+describe('gog_sheets_insert', () => {
+  it('calls runOrDiagnose with required args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_insert')!({ spreadsheetId: 'sid', sheet: 'Sheet1', dimension: 'ROWS', start: 5 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'insert', 'sid', 'Sheet1', 'ROWS', '5'], { account: undefined });
+  });
+
+  it('includes --count and --after when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_insert')!({ spreadsheetId: 'sid', sheet: 'S1', dimension: 'COLUMNS', start: 0, count: 3, after: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'insert', 'sid', 'S1', 'COLUMNS', '0', '--count=3', '--after'], { account: undefined });
+  });
+
+  it('includes --count=0 when count is 0', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_insert')!({ spreadsheetId: 'sid', sheet: 'S1', dimension: 'ROWS', start: 0, count: 0 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'insert', 'sid', 'S1', 'ROWS', '0', '--count=0'], { account: undefined });
+  });
+
+  it('omits --after when false', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_insert')!({ spreadsheetId: 'sid', sheet: 'S1', dimension: 'ROWS', start: 0, after: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'insert', 'sid', 'S1', 'ROWS', '0'], { account: undefined });
+  });
+});
+
+// 8. merge
+describe('gog_sheets_merge', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_merge')!({ spreadsheetId: 'sid', range: 'A1:C3' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'merge', 'sid', 'A1:C3'], { account: undefined });
+  });
+
+  it('includes --type when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_merge')!({ spreadsheetId: 'sid', range: 'A1:C3', type: 'MERGE_COLUMNS' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'merge', 'sid', 'A1:C3', '--type=MERGE_COLUMNS'], { account: undefined });
+  });
+});
+
+// 9. unmerge
+describe('gog_sheets_unmerge', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_unmerge')!({ spreadsheetId: 'sid', range: 'A1:C3' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'unmerge', 'sid', 'A1:C3'], { account: undefined });
+  });
+});
+
+// 10. format
+describe('gog_sheets_format', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    const fj = '{"textFormat":{"bold":true}}';
+    await handlers.get('gog_sheets_format')!({ spreadsheetId: 'sid', range: 'A1:B2', formatJson: fj });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'format', 'sid', 'A1:B2', `--format-json=${fj}`], { account: undefined });
+  });
+
+  it('includes --format-fields when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_format')!({ spreadsheetId: 'sid', range: 'A1', formatJson: '{}', formatFields: 'textFormat.bold' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'format', 'sid', 'A1', '--format-json={}', '--format-fields=textFormat.bold'], { account: undefined });
+  });
+});
+
+// 11. number-format
+describe('gog_sheets_number_format', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_number_format')!({ spreadsheetId: 'sid', range: 'A1:A10' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'number-format', 'sid', 'A1:A10'], { account: undefined });
+  });
+
+  it('includes --type and --pattern when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_number_format')!({ spreadsheetId: 'sid', range: 'A1', type: 'CURRENCY', pattern: '#,##0.00' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'number-format', 'sid', 'A1', '--type=CURRENCY', '--pattern=#,##0.00'], { account: undefined });
+  });
+});
+
+// 12. read-format
+describe('gog_sheets_read_format', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_read_format')!({ spreadsheetId: 'sid', range: 'A1:B2' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'read-format', 'sid', 'A1:B2'], { account: undefined });
+  });
+
+  it('includes --effective when true', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_read_format')!({ spreadsheetId: 'sid', range: 'A1', effective: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'read-format', 'sid', 'A1', '--effective'], { account: undefined });
+  });
+
+  it('omits --effective when false', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_read_format')!({ spreadsheetId: 'sid', range: 'A1', effective: false });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'read-format', 'sid', 'A1'], { account: undefined });
+  });
+});
+
+// 13. resize-columns
+describe('gog_sheets_resize_columns', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_resize_columns')!({ spreadsheetId: 'sid', columns: 'A:C' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'resize-columns', 'sid', 'A:C'], { account: undefined });
+  });
+
+  it('includes --width and --auto when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_resize_columns')!({ spreadsheetId: 'sid', columns: 'A:C', width: 200, auto: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'resize-columns', 'sid', 'A:C', '--width=200', '--auto'], { account: undefined });
+  });
+
+  it('includes --width=0 when width is 0', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_resize_columns')!({ spreadsheetId: 'sid', columns: 'A:A', width: 0 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'resize-columns', 'sid', 'A:A', '--width=0'], { account: undefined });
+  });
+});
+
+// 14. resize-rows
+describe('gog_sheets_resize_rows', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_resize_rows')!({ spreadsheetId: 'sid', rows: '1:10' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'resize-rows', 'sid', '1:10'], { account: undefined });
+  });
+
+  it('includes --height and --auto when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_resize_rows')!({ spreadsheetId: 'sid', rows: '1:5', height: 40, auto: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'resize-rows', 'sid', '1:5', '--height=40', '--auto'], { account: undefined });
+  });
+
+  it('includes --height=0 when height is 0', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_resize_rows')!({ spreadsheetId: 'sid', rows: '1:1', height: 0 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'resize-rows', 'sid', '1:1', '--height=0'], { account: undefined });
+  });
+});
+
+// 15. notes
+describe('gog_sheets_notes', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_notes')!({ spreadsheetId: 'sid', range: 'A1:B5' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'notes', 'sid', 'A1:B5'], { account: undefined });
+  });
+});
+
+// 16. update-note
+describe('gog_sheets_update_note', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_update_note')!({ spreadsheetId: 'sid', range: 'A1', note: 'Hello' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'update-note', 'sid', 'A1', '--note=Hello'], { account: undefined });
+  });
+
+  it('passes empty string to clear note', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_update_note')!({ spreadsheetId: 'sid', range: 'A1', note: '' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'update-note', 'sid', 'A1', '--note='], { account: undefined });
+  });
+});
+
+// 17. links
+describe('gog_sheets_links', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_links')!({ spreadsheetId: 'sid', range: 'A1:Z100' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'links', 'sid', 'A1:Z100'], { account: undefined });
+  });
+});
+
+// 18. named-ranges list
+describe('gog_sheets_named_ranges_list', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_named_ranges_list')!({ spreadsheetId: 'sid' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'named-ranges', 'list', 'sid'], { account: undefined });
+  });
+});
+
+// 19. named-ranges get
+describe('gog_sheets_named_ranges_get', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_named_ranges_get')!({ spreadsheetId: 'sid', nameOrId: 'MyRange' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'named-ranges', 'get', 'sid', 'MyRange'], { account: undefined });
+  });
+});
+
+// 20. named-ranges add
+describe('gog_sheets_named_ranges_add', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_named_ranges_add')!({ spreadsheetId: 'sid', name: 'Totals', range: 'Sheet1!A1:B10' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'named-ranges', 'add', 'sid', 'Totals', 'Sheet1!A1:B10'], { account: undefined });
+  });
+});
+
+// 21. named-ranges update
+describe('gog_sheets_named_ranges_update', () => {
+  it('calls runOrDiagnose with no optional flags', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_named_ranges_update')!({ spreadsheetId: 'sid', nameOrId: 'MyRange' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'named-ranges', 'update', 'sid', 'MyRange'], { account: undefined });
+  });
+
+  it('includes --name and --range when provided', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_named_ranges_update')!({ spreadsheetId: 'sid', nameOrId: 'MyRange', name: 'NewName', range: 'Sheet1!C1:D5' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'named-ranges', 'update', 'sid', 'MyRange', '--name=NewName', '--range=Sheet1!C1:D5'], { account: undefined });
+  });
+});
+
+// 22. named-ranges delete
+describe('gog_sheets_named_ranges_delete', () => {
+  it('calls runOrDiagnose with correct args', async () => {
+    vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
+    const handlers = setupHandlers();
+    await handlers.get('gog_sheets_named_ranges_delete')!({ spreadsheetId: 'sid', nameOrId: 'OldRange' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['sheets', 'named-ranges', 'delete', 'sid', 'OldRange'], { account: undefined });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "../gogcli-mcp" }]
+}

package/vitest.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    coverage: {
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      exclude: ['src/index.ts'],
+      thresholds: {
+        lines: 100,
+        functions: 100,
+        branches: 100,
+        statements: 100,
+      },
+    },
+  },
+});