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

mcp_gee_sweet-0.7.0.dev80/.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.dev80/.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.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.dev74 → 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/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.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.dev74 → 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.dev74
+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.dev74 → 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.dev74 → 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.dev74 → mcp_gee_sweet-0.7.0.dev80}/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.dev74 → 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.dev74 → mcp_gee_sweet-0.7.0.dev80}/tests/test_cache.py

@@ -1,4 +1,5 @@
 import os
+import sqlite3
 import time
 
 from mcp_gee_sweet.cache import (
@@ -8,6 +9,8 @@ from mcp_gee_sweet.cache import (
     SheetInfo,
     SheetStructureCache,
     _open,
+    _safe_fetchone,
+    _safe_write,
 )
 
 # All tests use an in-memory SQLite database.
@@ -282,6 +285,63 @@ class TestSharedDb:
         assert doc.get("fid") is not None  # different namespace, unaffected
 
 
+class TestBusyTimeout:
+    """issue #234: a busy_timeout must be set so a concurrent writer from another
+    session waits instead of raising SQLITE_BUSY immediately."""
+
+    def test_busy_timeout_is_set(self, tmp_path):
+        db = str(tmp_path / "test.db")
+        conn = _open(db)
+        try:
+            (value,) = conn.execute("PRAGMA busy_timeout").fetchone()
+            assert value == 5000
+        finally:
+            conn.close()
+
+
+class TestFailOpenOnSqliteError:
+    """issue #234: a cache read/write must never crash a tool call — any sqlite
+    error (locked/corrupted DB from another session) is treated as a cache miss
+    on reads and silently dropped on writes."""
+
+    def test_safe_fetchone_returns_none_on_error(self):
+        conn = sqlite3.connect(":memory:")
+        conn.close()  # any operation on a closed connection raises sqlite3.ProgrammingError
+        assert _safe_fetchone(conn, "SELECT 1", ()) is None
+
+    def test_safe_write_swallows_error(self):
+        conn = sqlite3.connect(":memory:")
+        conn.close()
+        _safe_write(conn, "SELECT 1", ())  # must not raise
+
+    def test_cache_get_survives_closed_connection(self):
+        cache = SheetStructureCache(db_path=":memory:", ttl=60)
+        cache.store("sid", [SheetInfo(title="S1", sheet_id=0)])
+        cache._conn.close()
+        assert cache.get_sheets("sid") is None
+
+    def test_cache_store_survives_closed_connection(self):
+        cache = SheetStructureCache(db_path=":memory:", ttl=60)
+        cache._conn.close()
+        cache.store("sid", [SheetInfo(title="S1", sheet_id=0)])  # must not raise
+
+    def test_mark_dirty_survives_closed_connection(self):
+        cache = SheetStructureCache(db_path=":memory:", ttl=60)
+        cache._conn.close()
+        cache.mark_dirty("sid")  # must not raise
+
+    def test_mark_all_dirty_survives_closed_connection(self):
+        cache = SheetStructureCache(db_path=":memory:", ttl=60)
+        cache._conn.close()
+        cache.mark_all_dirty()  # must not raise
+
+    def test_doc_cache_get_survives_closed_connection(self):
+        cache = DocContentCache(db_path=":memory:", ttl=60)
+        cache.store("fid", {"title": "Doc"})
+        cache._conn.close()
+        assert cache.get("fid") is None
+
+
 class TestOpenFallback:
     """_open() must survive a read-only or corrupted DB file without crashing."""