mcp-gee-sweet 0.7.0.dev72__tar.gz → 0.7.0.dev76__tar.gz

mcp_gee_sweet-0.7.0.dev76/.claude/commands/cleanup-worktrees.md

@@ -0,0 +1,15 @@
+Remove worktrees under `.claude/worktrees/` whose branch has a merged PR, so completed tickets don't pile up as stale directories. Safe by default: never deletes anything with uncommitted or unpushed changes — those are reported, not touched.
+
+1. List current worktrees: `git worktree list --porcelain`. Skip the main checkout (the entry with no `.claude/worktrees/` path).
+2. For each remaining worktree, get its branch name and check whether it has a merged PR:
+   ```
+   gh pr list --repo khuisman/mcp-gee-sweet --state merged --head <branch> --json number,url,mergedAt
+   ```
+3. For each worktree whose branch has a merged PR, check it's safe to remove:
+   - No uncommitted changes: `git -C <path> status --porcelain` must be empty.
+   - No unpushed commits: `git -C <path> log @{upstream}.. --oneline` must be empty (if the branch has no upstream, e.g. already deleted on the remote post-merge, treat a clean `status --porcelain` as sufficient).
+   - If both checks pass, remove it: `git worktree remove <path>`, then `git branch -d <branch>`.
+   - If either check fails, skip it and note what's uncommitted or unpushed — never force-remove.
+4. Leave alone any worktree whose branch has no merged PR (open PR, no PR yet, or PR closed without merging).
+5. Run `git worktree prune` to clear any stale administrative entries left behind.
+6. Report a summary: worktrees removed (with their PR link), worktrees skipped as dirty (with what's blocking removal), and worktrees still open (with PR/issue status).

mcp_gee_sweet-0.7.0.dev76/.claude/commands/merge-pr.md

@@ -0,0 +1,13 @@
+Merge the current branch's PR and clean up its worktree. Uses `--admin` only to bypass the required-review gate (this is a solo-maintainer repo, so a second approver is never coming) — it must never be used to bypass a failing or pending status check.
+
+1. Get the PR for the current branch: `gh pr view --json number,title,url,state,mergeable,statusCheckRollup,reviewDecision`. If there's no open PR for this branch, stop and tell the user.
+2. Verify it's actually safe to merge:
+   - `state` must be `OPEN`.
+   - Every check in `statusCheckRollup` (in particular "Lint and test") must show success. If anything is failing or still pending, stop and report which — do not merge, and do not wait/poll.
+   - `mergeable` must not be `CONFLICTING`.
+3. Show the user a summary: PR number, title, URL, check status, and review status (expected to be blocked only on the missing-approval requirement). State plainly that merging will use `--admin` to bypass that review gate. Ask for explicit confirmation before proceeding.
+4. On confirmation, squash-merge (matching this repo's existing history — commits land on `develop` as a single `title (#number)` commit): `gh pr merge <number> --admin --squash`. The remote branch is auto-deleted on merge (repo setting), so don't pass `--delete-branch`.
+5. Clean up the local worktree:
+   - If this session created the current worktree (i.e. it got here via `/start-worktree` or `/next-issue` earlier in this same session), use `ExitWorktree` with `action: "remove"`.
+   - Otherwise (worktree predates this session), fall back to manual cleanup from the main checkout: `git worktree remove <path>`, then `git branch -d <branch>`, then `git worktree prune`.
+6. Report a summary: the merge commit, the now-merged PR URL, and confirmation the worktree was removed.

mcp_gee_sweet-0.7.0.dev76/.claude/commands/start-worktree.md

@@ -0,0 +1,9 @@
+Create an isolated git worktree for parallel work in this repo, with the same local configuration as the main checkout (credentials, env, and a synced virtualenv), so it can run alongside other sessions without touching their branches or files.
+
+1. Determine the worktree name: use the argument passed to this command if given (e.g. an issue number or short slug, sanitized to letters/digits/dots/underscores/dashes). If no argument was given, ask the user for a short name before proceeding.
+2. Call `EnterWorktree` with that name. This creates the worktree under `.claude/worktrees/<name>/`, branches it from `origin/develop` (the repo's default branch), and switches the session into it.
+3. Copy the untracked local config that `git worktree` does not check out, from the original repo root (the directory the session was in before `EnterWorktree`) into the new worktree root: `.env`, `credentials.json`, `service_account.json`, `token.json`, `.claude/settings.local.json`. Skip any file that doesn't exist in the source.
+4. Run `uv sync` in the new worktree to build its own virtualenv — worktrees don't share `.venv`.
+5. Confirm the worktree is ready: report its path and current branch to the user.
+
+Do not modify the original checkout's files. If the user later asks to leave this worktree, use `ExitWorktree` with `keep` unless they explicitly say to discard the work.

{mcp_gee_sweet-0.7.0.dev72 → mcp_gee_sweet-0.7.0.dev76}/.github/workflows/ci.yml

@@ -17,7 +17,7 @@ jobs:
       - uses: actions/checkout@v7
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v8.2.0
+        uses: astral-sh/setup-uv@v8.3.0
 
       - name: Set up Python 3.12
         run: uv python install 3.12

{mcp_gee_sweet-0.7.0.dev72 → mcp_gee_sweet-0.7.0.dev76}/.github/workflows/docs.yml

@@ -18,7 +18,7 @@ jobs:
           fetch-depth: 0  # full history so mike can see existing gh-pages versions
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v8.2.0
+        uses: astral-sh/setup-uv@v8.3.0
 
       - name: Set up Python 3.12
         run: uv python install 3.12

{mcp_gee_sweet-0.7.0.dev72 → mcp_gee_sweet-0.7.0.dev76}/.github/workflows/publish-dev.yml

@@ -23,7 +23,7 @@ jobs:
           fetch-depth: 0  # full history so uv-dynamic-versioning can read tags
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v8.2.0
+        uses: astral-sh/setup-uv@v8.3.0
 
       - name: Set up Python 3.12
         run: uv python install 3.12
@@ -45,7 +45,7 @@ jobs:
           fetch-depth: 0  # full history so uv-dynamic-versioning can read tags
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v8.2.0
+        uses: astral-sh/setup-uv@v8.3.0
 
       - name: Set up Python 3.12
         run: uv python install 3.12

{mcp_gee_sweet-0.7.0.dev72 → mcp_gee_sweet-0.7.0.dev76}/.github/workflows/release.yml

@@ -15,7 +15,7 @@ jobs:
       - uses: actions/checkout@v7
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v8.2.0
+        uses: astral-sh/setup-uv@v8.3.0
 
       - name: Set up Python 3.12
         run: uv python install 3.12
@@ -36,7 +36,7 @@ jobs:
           fetch-depth: 0
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v8.2.0
+        uses: astral-sh/setup-uv@v8.3.0
 
       - name: Set up Python 3.12
         run: uv python install 3.12

{mcp_gee_sweet-0.7.0.dev72 → mcp_gee_sweet-0.7.0.dev76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-gee-sweet
-Version: 0.7.0.dev72
+Version: 0.7.0.dev76
 Summary: MCP server for Google Workspace — Sheets, Drive, Docs, and Calendar. 60+ tools for AI clients.
 Project-URL: Homepage, https://github.com/khuisman/mcp-gee-sweet
 Project-URL: Bug Tracker, https://github.com/khuisman/mcp-gee-sweet/issues

{mcp_gee_sweet-0.7.0.dev72 → mcp_gee_sweet-0.7.0.dev76}/docs/design/docs-ast-pipeline.md

@@ -266,13 +266,13 @@ New tests to add:
 | Column widths | Yes | #66 |
 | Colspan | Yes | #67 partial |
 | Rowspan | Yes | `Cell.rowspan` in AST; #91 added `mergeTableCells` in emitter |
-| Nested tables | Yes | `Cell.nested_table: Table \| None`; #92 added stages 3+5 in `fill_tables` |
+| Nested tables | Yes | `Cell.nested_table: Table \| None`; #92 added stages 3+5 in `fill_tables`. Superseded 2026-07-06 by `Cell.children: list[Run \| Table]` — see "Nested Table Rewrite" below |
 | Phase 3 styling fields (colors, fonts) | No | In AST as `None`; emitter ignores them |
 | `<ol>` ordered bullets | Yes | `BulletItem.ordered` → different bullet preset |
 
 ---
 
-## Nested Table Design (#92)
+## Nested Table Design (#92, superseded 2026-07-06 by #108/#275 — see below)
 
 **Date:** 2026-06-19
 
@@ -294,9 +294,47 @@ A `<table>` inside a `<td>` is now supported (one level of nesting).
 
 **Phase 5 — fill nested cells**: after outer cell text is filled (phase 4), indices shift. A second re-fetch is performed, then `_collect_nested_table_pairs(doc_tables, ast_tables)` traverses cell content to find the nested `table` element and pairs it with the AST `Table`. `_build_fill_requests` reuses the same logic as outer cells.
 
-### Known limitations (first pass)
+### Known limitations (first pass, now historical — see rewrite below)
 
-- One level of nesting only (table-in-table-in-table not supported)
-- Cells with `nested_table` should not also contain text runs (runs are dropped silently)
-- No `colspan`/`rowspan` inside nested tables
-- No `col_widths` on nested tables
+- Cells with `nested_table` should not also contain text runs (runs are dropped silently) — **fixed and superseded**, see below
+- One level of nesting only (table-in-table-in-table not supported) — **fixed and superseded**, see below
+- No `colspan`/`rowspan` inside nested tables — still true
+- No `col_widths` on nested tables — still true
+
+---
+
+## Nested Table Rewrite: `Cell.children` + recursive fill (#108, #275)
+
+**Date:** 2026-07-06
+
+The single-`nested_table`-field design above had two real defects, both found while investigating #108:
+
+1. Text sharing a cell with a nested table was silently corrupted. Root cause was in the parser, not the emitter: `_AstParser._run_buf`/`_pending_runs` are shared, unscoped state across nesting levels — opening a nested `<table>` never flushed them, so text typed before the nested table bled into the *nested* table's own first cell instead of staying with the outer cell.
+2. Even once the parser stopped corrupting it, the single `Cell.runs` field had nowhere to put "text after the table" separately from "text before the table" — `fill_tables` always inserted a cell's text at its first paragraph, i.e. always immediately *before* any nested table, regardless of where the text actually appeared in the source HTML. Filed as follow-up #275 rather than silently expanding #108's scope; then, per explicit direction, fixed in the same pass ("do the fuller version").
+
+### Schema change (`ast.py`)
+
+`Cell.runs: list[Run]` + `Cell.nested_table: Table | None` → **`Cell.children: list[Run | Table]`** — one ordered list holding exactly what appeared in the source, in order. This is the `Union[Run, Table]` design #92 originally proposed and explicitly didn't ship; the simpler two-field version turned out to be insufficient once #275 surfaced.
+
+### Parser changes (`html_parser.py`)
+
+`_TableBuilder` replaces `_current_nested_table`/`_pending_leading_runs` with a single `_current_children: list[Run | Table]`, plus `append_runs()`/`append_nested_table()` methods that append to it in call order. `_AstParser.handle_starttag`'s `table` branch flushes pending runs onto the *outer* builder via `append_runs()` before pushing a new builder for the nested table (fixing defect 1 above); `handle_endtag`'s `table` branch calls `append_nested_table()` on the parent builder instead of setting a single field. `end_cell` builds `Cell(children=self._current_children + runs, ...)`. This works at arbitrary depth and for arbitrarily many nested tables per cell — no explicit depth/count limit needed.
+
+### Emitter changes (`emitter.py`)
+
+Cells with no `Table` in `children` are still filled in one bulk batch by `_build_fill_requests` (unchanged, fast path — most cells). Cells with at least one `Table` child go through a new recursive, round-based algorithm:
+
+- **`_fill_children_recursive(docs_service, doc_id, resolve, ast_tables)`** — `resolve(live_doc) -> doc_table dicts` positionally matching `ast_tables`. Tracks a per-cell cursor into `children`. Each round: for every still-pending cell, emit **one** contiguous segment — either a run of text (`insertText` + styles) or one nested table's shell (`insertTable`) — at that cell's next open position, sorted high→low within the round (same pattern as the old phase-3/5 code), then re-fetch before the next round.
+  - **`_cell_para_start_for_cursor`**: a cell's `content` alternates paragraph/table/paragraph/table/...; the Nth paragraph (0-indexed) is the one after the Nth already-inserted table, where N = count of `Table` children before `cursor`.
+  - **`_text_offset_since_last_table`**: a table's insertion point is its paragraph's `startIndex` *plus* this — the length of any text already inserted into that same paragraph earlier in this round-chain (the paragraph's own `startIndex` doesn't change when text is inserted into it, but the table must land after that text, not at the start).
+  - When a table shell is inserted, **`_fill_table_fully`** is called for it: re-fetches, bulk-fills its own plain cells via `_build_fill_requests`, then recurses via `_fill_children_recursive` for any of *its* cells that themselves contain a further nested table. This is what makes nesting depth unbounded — a nested table is filled exactly the same way a top-level one is.
+  - After recursing into any nested tables inserted in a round (which run their own `batchUpdate`s and shift subsequent document indices), the outer loop re-fetches again before its own next round — recursion's mutations must be visible before the outer cell's next segment (e.g. trailing text) is positioned.
+- `_ast_cell_to_doc_cell` / `_find_nth_table_in_cell` locate a specific physical doc cell / the Nth nested-table content element inside a cell, reusing the existing `_physical_to_ast_indices`/`_build_phantom_set` colspan/rowspan-aware mapping.
+
+`_build_nested_table_inserts` and `_collect_nested_table_pairs` (the old phase-3/5 helpers) are removed — fully superseded by the recursive algorithm.
+
+### Result
+
+- Text before, between, and after any number of nested tables in one cell renders in true source order, at any nesting depth.
+- The "one level of nesting only" and "no colspan/rowspan/col_widths inside nested tables" limitations from the original #92 design are otherwise unchanged — this rewrite only touches content ordering, not those structural features.
+- Tested with `tests/test_docs_tables.py`'s `TestFillNestedCellContent`, which drives the real algorithm against a small in-memory Docs-API simulator (`FakeDoc`/`Para`/`TableNode` in that file) that actually applies `insertText`/`insertTable` mutations and re-derives indices — chosen over hand-computed index fixtures because this much re-fetch/recursion logic is easy to get subtly wrong in a way a fixture can't catch (and did, twice, during development).

{mcp_gee_sweet-0.7.0.dev72 → mcp_gee_sweet-0.7.0.dev76}/docs/qa/tests/docs.md

@@ -939,6 +939,87 @@ These test the HTML→AST→Docs API pipeline introduced in Phase 2 (#87). All u
 
 ---
 
+### TC-DOC84: Text sharing a cell with a nested table is no longer dropped (issue #108) ⚠️ destructive
+**Prompt**
+**Playwright: required**
+> "Write this HTML to doc {DOC_ID}: `<table><tr><td>Some label <table><tr><td>Inner</td></tr></table></td></tr></table>`"
+
+**Checks**
+- Call succeeds with no API error
+- `get_doc_structure` shows the outer table (1 row × 1 col) with a non-empty text run in cell [0,0] (previously this cell's text was silently dropped — bled into the nested table's own cell instead)
+- 🔍 Visual check: "Some label" appears above/before the nested table inside the outer cell, and the nested table's own cell reads "Inner" (not "Some label Inner" merged together)
+
+**Cleanup:** write fixture content back
+
+**Result (2026-07-06) ✅ PASS** `get_doc_structure` shows outer cell [0,0] `text: "Some label"` (previously empty per TC-DOC48's bug pattern). Playwright screenshot confirms "Some label" renders above the nested table, whose own cell reads exactly "Inner" — no merging.
+
+---
+
+### TC-DOC85: Text after a nested table in the same cell, correctly positioned (issue #275) ⚠️ destructive
+**Prompt**
+**Playwright: required**
+> "Write this HTML to doc {DOC_ID}: `<table><tr><td><table><tr><td>Inner</td></tr></table>After</td></tr></table>`"
+
+**Checks**
+- Call succeeds with no API error
+- `get_doc_structure` shows the outer cell's text as "After" — content intact, not merged with "Inner"
+- 🔍 Visual check: "After" renders *below* the nested table, not above it
+
+**Cleanup:** write fixture content back
+
+**Result (2026-07-07) ✅ PASS** `get_doc_structure` cell [0,0] `text: "After"`. Playwright confirms "After" renders below the nested table ("Inner"). Note: an earlier pass of this test case (2026-07-06) incorrectly expected "After" to render *above* the table — that was the pre-#275-fix limitation (a cell's text always rendered as one block before any nested table, regardless of source order). #275 fixed the emitter to place text on the correct side of each nested table; this test case's expectation and prompt were updated to match.
+
+---
+
+### TC-DOC86: Text before AND after one nested table, both correctly positioned (issue #275) ⚠️ destructive
+**Prompt**
+**Playwright: required**
+> "Write this HTML to doc {DOC_ID}: `<table><tr><td>Before <table><tr><td>Inner</td></tr></table> After</td></tr></table>`"
+
+**Checks**
+- Call succeeds with no API error
+- `get_doc_structure` shows outer cell [0,0] text as `"Before \n After"` (the `\n` confirms two distinct paragraphs — before and after the table — not one merged block)
+- 🔍 Visual check: "Before" above the nested table, "Inner" inside it, "After" below it
+
+**Cleanup:** write fixture content back
+
+**Result (2026-07-07) ✅ PASS** `get_doc_structure` shows `text: "Before \n After"`. Playwright screenshot confirms all three pieces render in the correct order and position.
+
+---
+
+### TC-DOC87: Multiple nested tables in one cell with text between them (issue #275) ⚠️ destructive
+**Prompt**
+**Playwright: required**
+> "Write this HTML to doc {DOC_ID}: `<table><tr><td>A<table><tr><td>1</td></tr></table>B<table><tr><td>2</td></tr></table>C</td></tr></table>`"
+
+**Checks**
+- Call succeeds with no API error
+- `get_doc_structure` shows outer cell [0,0] text as `"A\nB\nC"` (three separate paragraphs — one per text segment between/around the two nested tables)
+- 🔍 Visual check: A, then a table containing "1", then B, then a second table containing "2", then C — all in that order
+
+**Cleanup:** write fixture content back
+
+**Result (2026-07-07) ✅ PASS** `get_doc_structure` shows `text: "A\nB\nC"`. Playwright screenshot confirms both nested tables render in the correct positions with "1" and "2" filled in, and A/B/C text correctly interleaved — a capability that didn't exist before #275 (previously only one nested table per cell was supported at all).
+
+---
+
+### TC-DOC88: `colspan="0"` clamps to 1 instead of producing a degenerate zero-column cell
+
+**Background:** Found via code review of PR #276 — `int(attr_dict.get("colspan") or 1)` only covers a *missing* colspan attribute; an explicit `colspan="0"` is a non-empty (truthy) string, so it survives the `or` and parses to the literal integer `0`. A cell that spans zero columns breaks downstream `num_cols` calculations used by the nested-table fill algorithm. Fixed by clamping colspan/rowspan to a minimum of 1 in `html_parser.py`.
+
+**Prompt**
+> "Write this HTML to doc {DOC_ID}: `<table><tr><td colspan="0">Wide</td><td>Next</td></tr></table>`"
+
+**Checks**
+- Call succeeds with no API error
+- `get_doc_structure` shows the table with `columns: 2` (not 1 or a broken/merged layout) — cell [0,0] text "Wide", cell [0,1] text "Next"
+
+**Cleanup:** write fixture content back
+
+**Result (2026-07-07) ✅ PASS** `get_doc_structure` shows `columns: 2`, cell [0,0] `text: "Wide"`, cell [0,1] `text: "Next"` — `colspan="0"` clamped to 1 and rendered as two normal side-by-side cells.
+
+---
+
 ### TC-DOC52: `get_doc_theme` scans body paragraph styles
 **Note:** `get_doc_theme` reads explicit per-paragraph and per-run styles from the document body. It returns data for AI-generated docs (where styles are set explicitly on runs); for standard docs whose styles are fully inherited from named style defaults it returns an empty dict.
 

{mcp_gee_sweet-0.7.0.dev72 → mcp_gee_sweet-0.7.0.dev76}/src/mcp_gee_sweet/cache.py

@@ -28,6 +28,9 @@ def _connect(path: str) -> sqlite3.Connection:
     conn = sqlite3.connect(path, check_same_thread=False)
     conn.row_factory = sqlite3.Row
     conn.execute("PRAGMA journal_mode=WAL")
+    # Concurrent Claude sessions share this DB file by default; without a busy_timeout
+    # a write from another session hits SQLITE_BUSY immediately instead of waiting.
+    conn.execute("PRAGMA busy_timeout=5000")
     conn.execute(_DDL)
     conn.commit()
     return conn
@@ -60,6 +63,33 @@ def _open(db_path: str) -> sqlite3.Connection:
         return _connect(":memory:")
 
 
+def _safe_fetchone(conn: sqlite3.Connection, sql: str, params: tuple) -> sqlite3.Row | None:
+    """Run a SELECT and fetchone(), treating any sqlite error as a cache miss.
+
+    Another session's crash can leave a locked/corrupted WAL behind; a cache read
+    should never take down a tool call over it (fail open, same as the API-fetch
+    fallback in fetch_sheets()).
+    """
+    try:
+        return conn.execute(sql, params).fetchone()
+    except sqlite3.Error as exc:
+        logger.warning("Cache read failed (%s), treating as cache miss", exc)
+        return None
+
+
+def _safe_write(conn: sqlite3.Connection, sql: str, params: tuple) -> None:
+    """Run a write statement + commit, swallowing sqlite errors (fail-open cache write).
+
+    A failed cache write must not fail the tool call that already succeeded against
+    the underlying Google API — it just means that result won't be cached this time.
+    """
+    try:
+        conn.execute(sql, params)
+        conn.commit()
+    except sqlite3.Error as exc:
+        logger.warning("Cache write failed (%s), continuing without caching", exc)
+
+
 @dataclass
 class SheetInfo:
     title: str
@@ -75,19 +105,20 @@ class SheetStructureCache:
         logger.debug("Sheet structure cache opened: %s", db_path)
 
     def _get_valid(self, spreadsheet_id: str) -> sqlite3.Row | None:
-        row = self._conn.execute(
+        row = _safe_fetchone(
+            self._conn,
             "SELECT value, fetched_at, dirty FROM cache WHERE namespace=? AND key=?",
             (self._NS, spreadsheet_id),
-        ).fetchone()
+        )
         if row is None or row["dirty"]:
             return None
         if time.time() - row["fetched_at"] > self._ttl:
             logger.debug("Cache TTL expired for %s, marking dirty", spreadsheet_id)
-            self._conn.execute(
+            _safe_write(
+                self._conn,
                 "UPDATE cache SET dirty=1 WHERE namespace=? AND key=?",
                 (self._NS, spreadsheet_id),
             )
-            self._conn.commit()
             return None
         return row
 
@@ -109,33 +140,33 @@ class SheetStructureCache:
         value: dict = {"sheets": [{"title": s.title, "sheet_id": s.sheet_id} for s in sheets]}
         if title is not None:
             value["title"] = title
-        self._conn.execute(
+        _safe_write(
+            self._conn,
             "INSERT OR REPLACE INTO cache (namespace, key, value, fetched_at, dirty)"
             " VALUES (?,?,?,?,0)",
             (self._NS, spreadsheet_id, json.dumps(value), time.time()),
         )
-        self._conn.commit()
         logger.debug("Cached %d sheets for %s", len(sheets), spreadsheet_id)
 
     def mark_dirty(self, spreadsheet_id: str):
-        self._conn.execute(
+        _safe_write(
+            self._conn,
             "UPDATE cache SET dirty=1 WHERE namespace=? AND key=?",
             (self._NS, spreadsheet_id),
         )
-        self._conn.commit()
         logger.debug("Marked cache dirty for %s", spreadsheet_id)
 
     def mark_all_dirty(self):
-        self._conn.execute("UPDATE cache SET dirty=1 WHERE namespace=?", (self._NS,))
-        self._conn.commit()
+        _safe_write(self._conn, "UPDATE cache SET dirty=1 WHERE namespace=?", (self._NS,))
         logger.debug("Invalidated all sheet structure cache entries")
 
     def get_stale_sheets(self, spreadsheet_id: str) -> list[SheetInfo] | None:
         """Returns cached sheet list regardless of dirty/TTL state; None only on complete miss."""
-        row = self._conn.execute(
+        row = _safe_fetchone(
+            self._conn,
             "SELECT value FROM cache WHERE namespace=? AND key=?",
             (self._NS, spreadsheet_id),
-        ).fetchone()
+        )
         if row is None:
             return None
         return [SheetInfo(**s) for s in json.loads(row["value"])["sheets"]]
@@ -161,17 +192,17 @@ class SheetDataCache:
         self, spreadsheet_id: str, sheet_id: int, rows_to_fetch: int
     ) -> sqlite3.Row | None:
         key = self._key(spreadsheet_id, sheet_id)
-        row = self._conn.execute(
+        row = _safe_fetchone(
+            self._conn,
             "SELECT value, fetched_at, dirty, rows_fetched FROM cache WHERE namespace=? AND key=?",
             (self._NS, key),
-        ).fetchone()
+        )
         if row is None or row["dirty"]:
             return None
         if time.time() - row["fetched_at"] > self._ttl:
-            self._conn.execute(
-                "UPDATE cache SET dirty=1 WHERE namespace=? AND key=?", (self._NS, key)
+            _safe_write(
+                self._conn, "UPDATE cache SET dirty=1 WHERE namespace=? AND key=?", (self._NS, key)
             )
-            self._conn.commit()
             return None
         if (row["rows_fetched"] or 0) < rows_to_fetch:
             return None
@@ -198,7 +229,8 @@ class SheetDataCache:
         rows_to_fetch: int,
     ):
         value = {"headers": headers, "first_rows": first_rows}
-        self._conn.execute(
+        _safe_write(
+            self._conn,
             "INSERT OR REPLACE INTO cache (namespace, key, value, fetched_at, dirty, rows_fetched)"
             " VALUES (?,?,?,?,0,?)",
             (
@@ -209,27 +241,26 @@ class SheetDataCache:
                 rows_to_fetch,
             ),
         )
-        self._conn.commit()
         logger.debug("Cached sheet data for %s/%s", spreadsheet_id, sheet_id)
 
     def mark_dirty(self, spreadsheet_id: str, sheet_id: int | None = None):
         if sheet_id is not None:
-            self._conn.execute(
+            _safe_write(
+                self._conn,
                 "UPDATE cache SET dirty=1 WHERE namespace=? AND key=?",
                 (self._NS, self._key(spreadsheet_id, sheet_id)),
             )
             logger.debug("Marked sheet data dirty for %s/%s", spreadsheet_id, sheet_id)
         else:
-            self._conn.execute(
+            _safe_write(
+                self._conn,
                 "UPDATE cache SET dirty=1 WHERE namespace=? AND key LIKE ?",
                 (self._NS, f"{spreadsheet_id}:%"),
             )
             logger.debug("Marked all sheet data dirty for %s", spreadsheet_id)
-        self._conn.commit()
 
     def mark_all_dirty(self):
-        self._conn.execute("UPDATE cache SET dirty=1 WHERE namespace=?", (self._NS,))
-        self._conn.commit()
+        _safe_write(self._conn, "UPDATE cache SET dirty=1 WHERE namespace=?", (self._NS,))
         logger.debug("Invalidated all sheet data cache entries")
 
     def close(self):
@@ -251,17 +282,17 @@ class DriveFolderCache:
 
     def _get_valid(self, folder_id: str, mime_type: str | None) -> sqlite3.Row | None:
         key = self._key(folder_id, mime_type)
-        row = self._conn.execute(
+        row = _safe_fetchone(
+            self._conn,
             "SELECT value, fetched_at, dirty FROM cache WHERE namespace=? AND key=?",
             (self._NS, key),
-        ).fetchone()
+        )
         if row is None or row["dirty"]:
             return None
         if time.time() - row["fetched_at"] > self._ttl:
-            self._conn.execute(
-                "UPDATE cache SET dirty=1 WHERE namespace=? AND key=?", (self._NS, key)
+            _safe_write(
+                self._conn, "UPDATE cache SET dirty=1 WHERE namespace=? AND key=?", (self._NS, key)
             )
-            self._conn.commit()
             return None
         return row
 
@@ -274,25 +305,24 @@ class DriveFolderCache:
         return json.loads(row["value"])
 
     def store(self, folder_id: str, mime_type: str | None, files: list):
-        self._conn.execute(
+        _safe_write(
+            self._conn,
             "INSERT OR REPLACE INTO cache (namespace, key, value, fetched_at, dirty)"
             " VALUES (?,?,?,?,0)",
             (self._NS, self._key(folder_id, mime_type), json.dumps(files), time.time()),
         )
-        self._conn.commit()
         logger.debug("Cached %d files for folder %s (mime=%s)", len(files), folder_id, mime_type)
 
     def mark_dirty(self, folder_id: str):
-        self._conn.execute(
+        _safe_write(
+            self._conn,
             "UPDATE cache SET dirty=1 WHERE namespace=? AND key LIKE ?",
             (self._NS, f"{folder_id}:%"),
         )
-        self._conn.commit()
         logger.debug("Marked drive folder cache dirty for %s", folder_id)
 
     def mark_all_dirty(self):
-        self._conn.execute("UPDATE cache SET dirty=1 WHERE namespace=?", (self._NS,))
-        self._conn.commit()
+        _safe_write(self._conn, "UPDATE cache SET dirty=1 WHERE namespace=?", (self._NS,))
         logger.debug("Invalidated all drive folder cache entries")
 
     def close(self):
@@ -310,17 +340,19 @@ class DocContentCache:
         logger.debug("Doc cache opened: %s", db_path)
 
     def _get_valid(self, file_id: str) -> sqlite3.Row | None:
-        row = self._conn.execute(
+        row = _safe_fetchone(
+            self._conn,
             "SELECT value, fetched_at, dirty FROM cache WHERE namespace=? AND key=?",
             (self._NS, file_id),
-        ).fetchone()
+        )
         if row is None or row["dirty"]:
             return None
         if time.time() - row["fetched_at"] > self._ttl:
-            self._conn.execute(
-                "UPDATE cache SET dirty=1 WHERE namespace=? AND key=?", (self._NS, file_id)
+            _safe_write(
+                self._conn,
+                "UPDATE cache SET dirty=1 WHERE namespace=? AND key=?",
+                (self._NS, file_id),
             )
-            self._conn.commit()
             return None
         return row
 
@@ -333,25 +365,24 @@ class DocContentCache:
         return json.loads(row["value"])
 
     def store(self, file_id: str, doc: dict):
-        self._conn.execute(
+        _safe_write(
+            self._conn,
             "INSERT OR REPLACE INTO cache (namespace, key, value, fetched_at, dirty)"
             " VALUES (?,?,?,?,0)",
             (self._NS, file_id, json.dumps(doc), time.time()),
         )
-        self._conn.commit()
         logger.debug("Cached doc %s", file_id)
 
     def mark_dirty(self, file_id: str):
-        self._conn.execute(
+        _safe_write(
+            self._conn,
             "UPDATE cache SET dirty=1 WHERE namespace=? AND key=?",
             (self._NS, file_id),
         )
-        self._conn.commit()
         logger.debug("Marked doc cache dirty for %s", file_id)
 
     def mark_all_dirty(self):
-        self._conn.execute("UPDATE cache SET dirty=1 WHERE namespace=?", (self._NS,))
-        self._conn.commit()
+        _safe_write(self._conn, "UPDATE cache SET dirty=1 WHERE namespace=?", (self._NS,))
         logger.debug("Invalidated all doc cache entries")
 
     def close(self):
@@ -370,17 +401,17 @@ class CalendarCache:
         logger.debug("Calendar cache opened: %s", db_path)
 
     def _get_valid(self, key: str) -> sqlite3.Row | None:
-        row = self._conn.execute(
+        row = _safe_fetchone(
+            self._conn,
             "SELECT value, fetched_at, dirty FROM cache WHERE namespace=? AND key=?",
             (self._NS, key),
-        ).fetchone()
+        )
         if row is None or row["dirty"]:
             return None
         if time.time() - row["fetched_at"] > self._ttl:
-            self._conn.execute(
-                "UPDATE cache SET dirty=1 WHERE namespace=? AND key=?", (self._NS, key)
+            _safe_write(
+                self._conn, "UPDATE cache SET dirty=1 WHERE namespace=? AND key=?", (self._NS, key)
             )
-            self._conn.commit()
             return None
         return row
 
@@ -393,12 +424,12 @@ class CalendarCache:
         return json.loads(row["value"])
 
     def store_list(self, calendars: list):
-        self._conn.execute(
+        _safe_write(
+            self._conn,
             "INSERT OR REPLACE INTO cache (namespace, key, value, fetched_at, dirty)"
             " VALUES (?,?,?,?,0)",
             (self._NS, self._LIST_KEY, json.dumps(calendars), time.time()),
         )
-        self._conn.commit()
         logger.debug("Cached calendar list (%d entries)", len(calendars))
 
     def get(self, calendar_id: str) -> dict | None:
@@ -410,25 +441,23 @@ class CalendarCache:
         return json.loads(row["value"])
 
     def store(self, calendar_id: str, calendar: dict):
-        self._conn.execute(
+        _safe_write(
+            self._conn,
             "INSERT OR REPLACE INTO cache (namespace, key, value, fetched_at, dirty)"
             " VALUES (?,?,?,?,0)",
             (self._NS, calendar_id, json.dumps(calendar), time.time()),
         )
-        self._conn.commit()
         logger.debug("Cached calendar %s", calendar_id)
 
     def mark_dirty(self, calendar_id: str):
         for key in (calendar_id, self._LIST_KEY):
-            self._conn.execute(
-                "UPDATE cache SET dirty=1 WHERE namespace=? AND key=?", (self._NS, key)
+            _safe_write(
+                self._conn, "UPDATE cache SET dirty=1 WHERE namespace=? AND key=?", (self._NS, key)
             )
-        self._conn.commit()
         logger.debug("Marked calendar cache dirty for %s", calendar_id)
 
     def mark_all_dirty(self):
-        self._conn.execute("UPDATE cache SET dirty=1 WHERE namespace=?", (self._NS,))
-        self._conn.commit()
+        _safe_write(self._conn, "UPDATE cache SET dirty=1 WHERE namespace=?", (self._NS,))
         logger.debug("Invalidated all calendar cache entries")
 
     def close(self):

{mcp_gee_sweet-0.7.0.dev72 → mcp_gee_sweet-0.7.0.dev76}/src/mcp_gee_sweet/tools/docs/ast.py

@@ -43,8 +43,7 @@ class Run:
 
 @dataclass
 class Cell:
-    runs: list[Run]
-    nested_table: Table | None = None  # one nested table rendered inside this cell
+    children: list[Run | Table]  # ordered text runs and nested tables, in source order
     colspan: int = 1
     rowspan: int = 1
     is_header: bool = False