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

{mcp_gee_sweet-0.7.0.dev72 → mcp_gee_sweet-0.7.0.dev74}/.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.dev74}/.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.dev74}/.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.dev74}/.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.dev74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-gee-sweet
-Version: 0.7.0.dev72
+Version: 0.7.0.dev74
 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.dev74}/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.dev74}/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.dev74}/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