mcp-gee-sweet 0.7.0.dev74__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.dev74 → 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.dev74
+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.dev74 → 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.dev74 → mcp_gee_sweet-0.7.0.dev76}/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."""