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

mcp_gee_sweet-0.7.0.dev80/.claude/commands/orchestrator.md

@@ -0,0 +1,20 @@
+Establish this session as the **orchestrator** — the one session responsible for ticket triage, roadmap grooming, live testing, and reviewing/merging PRs, as opposed to a worker session doing ticket implementation in a worktree.
+
+Why this role split exists: any locally-configured MCP server that runs this project via `uv run --directory <path>` (check your global MCP config for one pointing at this repo), plus the `mcp-gee-sweet` docker-compose service (bind-mounts `./src`), always serve whatever is checked out at that fixed path — the main checkout, not whichever worktree a session's shell happens to be in. A worktree's code is invisible to every live MCP tool call until it's checked out in the main checkout or merged to the default branch. So only one place can ever do meaningful live testing — the main checkout — and only one session should treat it as home base at a time.
+
+1. Confirm this session is running from the main checkout, not a `.claude/worktrees/*` path. If it's in a worktree, tell the user the orchestrator role requires the main checkout and ask whether to `ExitWorktree` (`keep`) first.
+2. Check `git branch --show-current` and `git status --short` on the main checkout:
+   - On `develop` and clean: ready.
+   - On a feature branch, or dirty: flag it. Ticket implementation shouldn't live in the main checkout under this model — it blocks freely checking out other branches to live-test them. Ask the user whether to move that work into its own worktree (`start-worktree`) or continue as-is for now.
+3. Report current state so the user can steer:
+   - `git worktree list` — active worker worktrees
+   - `gh pr list --state open` — PRs awaiting live-test/review/merge (run from inside the repo so `gh` infers it from the git remote — don't hardcode a repo slug, forks won't match)
+   - `gh issue list --label ready-for-development --state open` — queued ticket(s)
+4. State the orchestrator's responsibilities plainly:
+   - Ticket triage and labeling (`ready-for-development`, version labels)
+   - Roadmap grooming (`docs/roadmap.md` + whichever roadmap-planning memory is currently active — check the memory index rather than assuming a specific version-numbered file)
+   - Live/manual tool testing — only possible here
+   - Reviewing worker PRs: `verify-pr` (code review + scoped live QA against real Google APIs) before `merge-pr`
+   - Worktree cleanup after merge (`cleanup-worktrees`)
+
+   Do NOT pick up ticket implementation directly in this session — hand it to a worker session via `start-worktree` (or `next-issue`, which does this automatically).

{mcp_gee_sweet-0.7.0.dev76 → mcp_gee_sweet-0.7.0.dev80}/.claude/commands/prep-for-pr.md

@@ -8,8 +8,8 @@ Review the current branch against this checklist and report the status of each i
 - [ ] **Unit tests passing** — has `uv run python -m pytest tests/` been run and passed?
 - [ ] **Regression coverage** — were tests that touch the modified files (not just new tests) also run?
 - [ ] **QA test cases written** — are there AI-driven test cases in `docs/qa/tests/` for the new/changed tools?
-- [ ] **QA tests run** — have those test cases been executed live against the fixture doc?
-- [ ] **QA results recorded** — does each test case have a `**Result (date) ✅/❌**` entry with actual observed output?
+
+**Live QA execution is out of scope for this checklist.** If this session is a worker in a `.claude/worktrees/*` checkout, running live QA tools here would exercise the main checkout's code, not this branch's changes — the result would look real but prove nothing. Do not run live tests and do not write `**Result**` entries from a worktree. That happens in the orchestrator's `/verify-pr` pass after the PR is open, in the main checkout, where the branch's actual code is reachable by the live MCP tools. Leave the `**Result**` line off new/changed test cases entirely — don't stub it as "pending," just omit it so `/verify-pr` adds the first real one.
 
 ## 2. QA test case tags
 

mcp_gee_sweet-0.7.0.dev80/.claude/commands/verify-pr.md

@@ -0,0 +1,33 @@
+Verify an open worker PR before merging: code review plus live QA testing against real Google APIs. This only works from the orchestrator session in the main checkout — see `/orchestrator` for why (live MCP tools always serve the main checkout's code, never a worktree's).
+
+CI (the "Lint and test" check `/merge-pr` already gates on) covers unit tests. It cannot cover code review judgment or live calls against real Google APIs, since those need credentials and fixtures CI doesn't have. That's what this skill does instead — it's the step between a worker's PR going up and `/merge-pr`.
+
+1. **Preconditions.** Confirm this session is in the main checkout, not a worktree (same check as `/orchestrator` step 1). If the main checkout has uncommitted changes, stop and ask the user how to proceed — don't stash or discard anything.
+
+2. **Identify the PR.** Take a PR number as an argument if given, otherwise use `gh pr list --state open` and ask the user which one if there's more than one. Get its details: `gh pr view <number> --json number,title,url,headRefName,baseRefName,statusCheckRollup`.
+
+3. **Check out the branch.** `gh pr checkout <number>`. This fetches and switches the main checkout to the PR's branch directly (no worktree needed — the orchestrator owns the main checkout).
+
+4. **Reconnect the MCP server.** The server hot-reloads on file change, but this Claude session's MCP connection stays on the old process. Tell the user to run:
+   ```
+   /mcp reconnect
+   ```
+   on its own line, standalone (not embedded in other text). Wait for confirmation before continuing — live tests run against stale code otherwise.
+
+5. **Code review.** Run `/code-review` at `high` effort against the diff (`<baseRefName>...<headRefName>`, typically `develop...HEAD`). Report findings before moving on to live testing — if it surfaces a correctness bug, ask the user whether to still proceed with live QA or send the PR back to the worker first.
+
+6. **Scope the live QA run.** Don't run the full suite. Find what this PR actually touches:
+   - `git diff origin/<baseRefName>...HEAD --name-only -- docs/qa/tests/` — new or modified test case files.
+   - Within those, identify test cases that are new or whose `Prompt`/`Setup`/`Checks` changed (not ones only touched by unrelated reflow). These are mandatory.
+   - Cross-check against `git diff origin/<baseRefName>...HEAD --name-only -- src/mcp_gee_sweet/tools/` — for each changed tool, confirm there's at least one QA test case covering it in scope; if a changed tool has no corresponding test case at all, flag that as a gap rather than silently skipping it.
+   - Existing passing test cases for the same tool (regression) are optional spot-checks, not mandatory re-runs — full regression is `docs/qa/run.md`'s job, run periodically, not per-PR.
+
+7. **Run the scoped test cases live.** Follow each test case's `Prompt`/`Setup` against the fixtures in `docs/qa/.env` (see `docs/qa/setup.md` if fixtures aren't configured), using the now-reconnected MCP tools. For `**Playwright: required**` cases, use the connected Playwright MCP if available; if not connected, tell the user and ask whether to proceed without visual verification or connect it first.
+
+8. **Record results honestly.** For each test case actually executed, add `**Result (<date>) ✅ PASS**` or `**Result (<date>) ❌ FAIL — <what happened>**` directly below its `Checks` block. Never write a Result for a case you didn't actually invoke — if something blocks a case (fixture missing, tool errors before completing), write `**Result (<date>)** pending — <reason>` and say so plainly rather than guessing the outcome.
+
+9. **Commit and push the results.** If any Result entries were added, commit just those QA doc changes onto the PR branch (`qa: record live verification for PR #<number>`) and push, so the evidence lands in history before merge. Ask before pushing, per this repo's normal commit/push confirmation rule.
+
+10. **Report.** Summarize: code review findings (if any), which test cases passed/failed/pending, any coverage gaps found in step 6, and whether the branch looks ready to merge. If everything passed, say the next step is `/merge-pr`. If something failed, say the PR needs to go back to its worker session — don't attempt the fix yourself here; this session's job is verification, not implementation.
+
+Leave the branch checked out either way — `/merge-pr` operates on the current branch's PR, and if it needs rework, the worker's own worktree still has the branch open there too.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-gee-sweet
-Version: 0.7.0.dev76
+Version: 0.7.0.dev80
 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.dev76 → mcp_gee_sweet-0.7.0.dev80}/docs/qa/tests/docs.md

@@ -1020,6 +1020,24 @@ These test the HTML→AST→Docs API pipeline introduced in Phase 2 (#87). All u
 
 ---
 
+### TC-DOC89: Degenerate table (row with no cells) followed by a real table doesn't desync content (issue #277)
+
+**Background:** `ast_to_requests` skips emitting an `insertTable` request for a table with zero rows or zero columns (e.g. a `<tr>` with no `<td>`s), but was still counting that table in the list it hands to `fill_tables()`. Since `fill_tables()` pairs AST tables against live-doc tables positionally, a skipped table shifted every later table's fill/merge/style requests onto the wrong doc table — silently, with no error. Fixed by excluding degenerate tables from that list at the source.
+
+**Prompt**
+> "Write this HTML to doc {DOC_ID}: `<table><tr></tr></table><table><tr><td>A</td><td>B</td></tr></table>`"
+
+**Checks**
+- Call succeeds with no API error
+- `get_doc_structure` shows exactly **one** table in the doc (the empty-row table produces no table element at all)
+- That table is `columns: 2` with cell [0,0] text "A" and cell [0,1] text "B" — not empty, not misapplied, not offset onto the wrong table
+
+**Cleanup:** write fixture content back
+
+**Result (2026-07-09) ✅ PASS**
+
+---
+
 ### 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.dev76 → mcp_gee_sweet-0.7.0.dev80}/docs/roadmap.md

@@ -96,6 +96,7 @@ No new tools. Stabilize on what Tier 1 shipped before starting Tier 2 feature wo
 
 **Defects** _(found after v0.8.1 shipped; too late for that release, don't warrant a standalone patch)_
 - [ ] Bare URLs in markdown content aren't autolinked — Python-Markdown's built-in autolink only fires on `<https://...>` or `[text](url)`, not a bare URL ([#248](https://github.com/khuisman/mcp-gee-sweet/issues/248))
+- [ ] `zip(doc_tables, ast_tables)` in `emitter.py` silently cross-pairs tables when one is skipped (zero-row/zero-col table), misapplying fill/merge/style requests to the wrong table — surfaced during #276's review ([#277](https://github.com/khuisman/mcp-gee-sweet/issues/277))
 
 **Sheets**
 - [ ] `update_borders` — border style, width, color on a range ([#122](https://github.com/khuisman/mcp-gee-sweet/issues/122)) _(freema/mcp-gsheets)_
@@ -130,6 +131,7 @@ No new tools. Stabilize on what Tier 1 shipped before starting Tier 2 feature wo
 - [ ] `create_shortcut` — create a Drive shortcut to a file ([#141](https://github.com/khuisman/mcp-gee-sweet/issues/141))
 - [ ] `sync_folder` — option to convert markdown files to Google Docs on upload ([#211](https://github.com/khuisman/mcp-gee-sweet/issues/211))
 - [ ] `upload_local_file` with Drive format conversion (CSV→Sheets, MD→Docs) ([#188](https://github.com/khuisman/mcp-gee-sweet/issues/188))
+- [ ] Expose `md5Checksum` in `list_files`/`get_file_metadata` for real content-diffing, and let `sync_folder` diff by checksum instead of/in addition to `modifiedTime` — mtime is unreliable across in-place overwrites, `upload_local_file`'s "now" stamp, and content-preserving regenerations; related to #239 ([#274](https://github.com/khuisman/mcp-gee-sweet/issues/274))
 - [x] Drive Activity API — file change history ([#72](https://github.com/khuisman/mcp-gee-sweet/issues/72))
 
 **Infrastructure**

{mcp_gee_sweet-0.7.0.dev76 → mcp_gee_sweet-0.7.0.dev80}/src/mcp_gee_sweet/tools/docs/emitter.py

@@ -28,6 +28,14 @@ def ast_to_requests(nodes: list[DocNode], start_index: int = 1) -> tuple[list[di
 
     for node in nodes:
         if isinstance(node, Table):
+            num_rows = len(node.rows)
+            num_cols = max((sum(c.colspan for c in row.cells) for row in node.rows), default=0)
+            if num_rows == 0 or num_cols == 0:
+                # No insertTable request is emitted below for a degenerate table, so it must
+                # not be added to `tables` either — fill_tables() zips this list positionally
+                # against the tables actually present in the live doc, and a table with no
+                # insertTable request never shows up there.
+                continue
             tables.append(node)
             table_positions.append(start_index + len(full_text))
         else:
@@ -105,16 +113,15 @@ def ast_to_requests(nodes: list[DocNode], start_index: int = 1) -> tuple[list[di
         table = tables[i]
         num_rows = len(table.rows)
         num_cols = max((sum(c.colspan for c in row.cells) for row in table.rows), default=0)
-        if num_rows > 0 and num_cols > 0:
-            requests.append(
-                {
-                    "insertTable": {
-                        "rows": num_rows,
-                        "columns": num_cols,
-                        "location": {"index": table_positions[i]},
-                    }
+        requests.append(
+            {
+                "insertTable": {
+                    "rows": num_rows,
+                    "columns": num_cols,
+                    "location": {"index": table_positions[i]},
                 }
-            )
+            }
+        )
 
     return requests, tables
 

{mcp_gee_sweet-0.7.0.dev76 → mcp_gee_sweet-0.7.0.dev80}/tests/test_docs_tables.py

@@ -12,10 +12,12 @@ from mcp_gee_sweet.tools.docs.ast import (
 from mcp_gee_sweet.tools.docs.content import _html_to_doc_requests
 from mcp_gee_sweet.tools.docs.emitter import (
     _ast_cell_to_doc_cell,
+    _build_fill_requests,
     _cell_para_start_for_cursor,
     _fill_nested_cell_content,
     _find_nth_table_in_cell,
     _text_offset_since_last_table,
+    ast_to_requests,
 )
 from mcp_gee_sweet.tools.docs.html_parser import html_to_ast
 
@@ -719,3 +721,41 @@ class TestFillNestedCellContent:
         degenerate = Table(rows=[Row(cells=[])])
         doc = self._run(Cell(children=[degenerate, Run("After")]))
         assert doc.describe_cell(0, 0, 0) == ["Para:After"]
+
+
+# ---------------------------------------------------------------------------
+# #277 — a skipped degenerate table must not desync doc_tables/ast_tables
+# ---------------------------------------------------------------------------
+
+
+class TestSkippedTableDoesNotDesyncTablePairing:
+    def test_empty_row_table_excluded_from_ast_to_requests_tables(self):
+        # A top-level <table><tr></tr></table> has a row but zero cells, so num_cols == 0
+        # and no insertTable request is emitted for it. It must not appear in the returned
+        # `tables` list either, or the table after it desyncs from doc_tables in fill_tables().
+        empty_table = _table(_row())
+        normal_table = _table(_row(_cell("hello")))
+        requests, tables = ast_to_requests([empty_table, normal_table])
+
+        table_inserts = [r for r in requests if "insertTable" in r]
+        assert len(table_inserts) == 1
+        assert tables == [normal_table]
+
+    def test_fill_requests_land_on_correct_table_after_a_skip(self):
+        # Simulates fill_tables(): doc_tables comes from the live doc, which only ever
+        # contains tables that actually got an insertTable request — i.e. never the
+        # skipped empty-row table. ast_tables must be the same (already-filtered) list
+        # returned by ast_to_requests, so the zip() stays 1:1.
+        empty_table = _table(_row())
+        normal_table = _table(_row(_cell("hello")))
+        _, tables = ast_to_requests([empty_table, normal_table])
+
+        doc_table = {
+            "tableRows": [{"tableCells": [{"startIndex": 9, "content": [{"startIndex": 10}]}]}]
+        }
+        fill_requests = _build_fill_requests([doc_table], tables)
+
+        insert_texts = [r["insertText"] for r in fill_requests if "insertText" in r]
+        assert len(insert_texts) == 1
+        assert insert_texts[0]["text"] == "hello"
+        assert insert_texts[0]["location"]["index"] == 10