mcp-gee-sweet 0.9.2.dev286__tar.gz → 0.9.2.dev289__tar.gz

{mcp_gee_sweet-0.9.2.dev286 → mcp_gee_sweet-0.9.2.dev289}/.claude/team-roles/kai.md

@@ -25,7 +25,7 @@ The incidents behind the rules in this file are in [`docs/decisions/role-file-hi
    - Team-process PRs (edits to `CLAUDE.md`, `.claude/team-roles/*.md`, `.claude/commands/*.md`) are Bob's own merge track, not Kai's — Bob reviews, labels `prompt-qa-approved`, and merges those himself (see `.claude/team-roles/bob.md` step 4). This used to be Kai's job too; per direct user instruction, 2026-07-21, it isn't anymore.
    - Cutting a release once Aziz has signed off (`/release`)
    - Worktree cleanup after merge (`cleanup-worktrees`) — this must never remove the persistent dev-team slot worktrees (the full `WORKTREE_ROLES` list in `scripts/setup_team.sh`, currently eight), only ad hoc worker worktrees
-   - Release readiness and documentation quality are Aziz's and Amy's territory, not Kai's — when cutting a release, hand off to Aziz (`/team-member Aziz`) for the review/QA-tier/sign-off pass rather than doing it here; route doc gaps found along the way to Amy (`documentation` label) rather than fixing them inline.
+   - Release readiness and documentation quality are Aziz's and Amy's territory, not Kai's — when cutting a release, hand off to Aziz (`/team-member Aziz`) for the review/QA-tier/sign-off pass rather than doing it here; route doc gaps found along the way to Amy (`documentation` label) rather than fixing them inline. Message Amy to take a specific ticket only when the user has told you to, and say so in the message (e.g. "the user asked me to hand you #N"): `amy.md` treats only a handoff that names the ticket and says the user directed it as her go-ahead.
 
    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), or to a dev-team lane via `/team-member` if the team is active.
 

{mcp_gee_sweet-0.9.2.dev286 → mcp_gee_sweet-0.9.2.dev289}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mcp-gee-sweet
-Version: 0.9.2.dev286
+Version: 0.9.2.dev289
 Summary: MCP server for Google Workspace — Sheets, Drive, Docs (HTML or Markdown), and Calendar.
 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.9.2.dev286 → mcp_gee_sweet-0.9.2.dev289}/docs/design/doc-to-markdown.md

@@ -120,6 +120,23 @@ Three gaps were kept **as documented limitations, not implementation shortcuts**
   next to ordinary text in the same paragraph — the one case it can't resolve (a paragraph
   containing *only* a single inline code span, nothing else) is the genuinely ambiguous case
   documented above, not a bug in the heuristic.
+- **Code delimiters** (#923, #940, #938): a code span's content is literal, so the serializer
+  can only pick a delimiter and padding. A fenced block's fence and an inline span's delimiter
+  are one backtick longer than the longest backtick run in the content (fences at least 3).
+  An inline span is padded with one space a side when its content starts or ends with a
+  backtick, or starts *and* ends with a space (CommonMark strips one space from each end in that
+  case). Adjacent code runs sharing a link merge into one span, since two spans side by side
+  would read as one. An inline code run's line breaks become `<br>` between separate spans: a
+  span can't hold a line break, and a raw newline could start a new block. In a table cell, a
+  code line containing `|` renders as raw HTML `<code>`, because the GFM `\|` escape shows its
+  backslash in renderers that don't implement it. Text inside raw HTML is still parsed as
+  Markdown, so every ASCII punctuation character in that line becomes a numeric entity
+  (`&#124;`, `&#42;`, `&#92;`, ...). Line breaks at either end of a linked code run go outside the
+  link. Because the exporter writes its own `<br>`/`<code>` HTML, plain text escapes `~`, a `<`
+  that could open a tag, and an `&` that starts an entity, so typed markup can't pass for
+  exporter markup. The export tests
+  check these against a strict CommonMark parser (`markdown-it-py`), since Python-Markdown
+  strips whitespace in code spans and closes a fence only on an exact-length match.
 - **Tight vs. loose lists**: consecutive `BulletItem` nodes are joined with a single `"\n"`
   rather than the `"\n\n"` used between other block types — CommonMark still parses a
   blank-line-separated run of list items as one list either way (just "loose", wrapped in `<p>`

{mcp_gee_sweet-0.9.2.dev286 → mcp_gee_sweet-0.9.2.dev289}/docs/qa/tests/docs_content.md

@@ -3541,6 +3541,69 @@ Edge spacers (single <br> each): markdown = "| Trailing test<br> |\n| --- |\n| <
 
 ---
 
+### TC-DOC206: Inline code keeps a space at both ends, and adjacent code runs export as one span (#938)
+**Setup:** raw HTML via `write_doc_content(doc_id={DOC_ID}, content_format='html', content="<p>pad <code> both ends </code> end</p><p>adj <code>x`</code><b><code>`y</code></b> end</p>")`. The bold change splits the second paragraph's code into two Courier New runs.
+
+**Prompt**
+> "Export doc {DOC_ID} as Markdown"
+
+**Checks**
+- `markdown` contains ``pad `  both ends  ` end``: one extra space a side, since CommonMark strips one space from each end when both ends have one
+- `markdown` contains ```` adj ```x``y``` end ````: the two runs merge into one span, with a three-backtick delimiter around the two-backtick run
+- Rendering `markdown` with a strict CommonMark renderer (e.g. `markdown-it-py`'s `commonmark` preset, not Python `markdown`, which strips code-span whitespace) gives `<code> both ends </code>` and `<code>x``y</code>`
+
+**Cleanup:** write fixture content back over `{DOC_ID}`
+
+**Result (2026-10-10) ✅ PASS — Kit, PR #968 round 1 (`d2449f7`).** `get_doc_as_markdown` returned ``pad `  both ends  ` end\n\nadj ```x``y``` end``. markdown-it-py 4.2.0's `commonmark` preset rendered `<code> both ends </code>` and `<code>x``y</code>`. Fixture content was written back.
+
+**Result (2026-10-10) ✅ PASS — Kit, PR #968 round 2 (`759362a`).** Re-run because the fix changed `_render_run`. Output was identical to round 1. Fixture content was written back.
+
+---
+
+### TC-DOC207: Inline code in a table cell keeps a literal `|` and puts line breaks outside the code (#938)
+**Setup:** raw HTML via `write_doc_content(doc_id={DOC_ID}, content_format='html', content="<table><tr><td>Head</td></tr><tr><td>pipe <code>a|b</code> and a|b</td></tr><tr><td><code>x</code><br><code>y|z</code></td></tr></table>")`. The last cell has two code-styled paragraphs.
+
+**Prompt**
+> "Export doc {DOC_ID} as Markdown"
+
+**Checks**
+- `markdown` contains the row `| pipe <code>a&#124;b</code> and a\|b |`: the code's pipe is an HTML entity inside raw `<code>`, with no backslash, and the plain-text pipe is still escaped
+- `markdown` contains the row `` | `x`<br><code>y&#124;z</code> | ``: the cell's paragraph break is a `<br>` between two code elements, not inside one
+- Rendering `markdown` with a GFM-table renderer (e.g. `markdown-it-py`'s `commonmark` preset with `table` enabled) gives a one-column table whose cells contain `<code>a|b</code>` and `<code>x</code><br><code>y|z</code>`. No cell shows a backslash
+
+Not covered live: a soft break (Shift+Enter) inside an inline code run in a paragraph that also has plain text. No tool can build one (`style_doc_range` doesn't set a font), so unit tests cover it (`TestInlineCodeCommonMark::test_newline_in_inline_code_does_not_start_a_new_block`).
+
+**Cleanup:** write fixture content back over `{DOC_ID}`
+
+**Result (2026-10-10) ✅ PASS (checks as written); ❌ probe beyond the case — Kit, PR #968 round 1 (`d2449f7`).** `get_doc_as_markdown` returned both expected rows exactly: `| pipe <code>a&#124;b</code> and a\|b |` and `` | `x`<br><code>y&#124;z</code> | ``. markdown-it-py's `commonmark` preset with `table` enabled rendered a one-column table with `<code>a|b</code>` and `<code>x</code><br><code>y|z</code>`, and no backslash. Probe: a cell with code `a|*b* _c_` exported as `<code>a&#124;*b* _c_</code>`, which renders `<em>` inside the `<code>`. A cell with code `C:\|x` exported as `<code>C:\&#124;x</code>`, which renders as `C:&amp;#124;x`. Both are sent back on the PR. Fixture content was written back.
+
+**Result (2026-10-10) ✅ PASS — Kit, PR #968 round 2 (`759362a`).** Re-run because the fix changed the table-cell `<code>` path. Both expected rows came back exactly, and the render was the same as round 1. The round 1 probe is now TC-DOC208, which passes. Fixture content was written back.
+
+---
+
+### TC-DOC208: Markdown punctuation inside table-cell `<code>`, linked code after a cell break, and HTML-like plain text all export literally (#938)
+**Setup:** raw HTML via `write_doc_content(doc_id={DOC_ID}, content_format='html', content=...)` with this content. The `\` in `C:\|x` is one literal backslash character.
+
+```html
+<table><tr><td>Head</td></tr><tr><td><code>a|*b* _c_</code></td></tr><tr><td><code>C:\|x</code></td></tr><tr><td><code>x</code><br><a href="https://example.com/b"><code>b</code></a></td></tr></table><p>Use &lt;br&gt; or &amp;#124; and ~~old~~, AT&amp;T a &lt; b</p>
+```
+
+**Prompt**
+> "Export doc {DOC_ID} as Markdown"
+
+**Checks**
+- `markdown` contains the row `| <code>a&#124;&#42;b&#42; &#95;c&#95;</code> |`: every punctuation character inside raw `<code>` is a numeric entity
+- `markdown` contains the row `| <code>C&#58;&#92;&#124;x</code> |`: the backslash is an entity too, so it can't escape the pipe's `&`
+- `markdown` contains the row `` | `x`<br>[`b`](https://example.com/b) | ``: the `<br>` from the cell's paragraph break is outside the link
+- `markdown` contains the paragraph `Use \<br> or \&#124; and \~\~old\~\~, AT&T a < b`: `<` before a tag, `&` starting an entity, and `~` are escaped; `AT&T` and `a < b` are not
+- Rendering `markdown` with `markdown-it-py`'s `commonmark` preset with `table` enabled gives cells `<code>a|*b* _c_</code>`, `<code>C:\|x</code>`, and `<code>x</code><br><a href="https://example.com/b"><code>b</code></a>`, with no `<em>` inside any `<code>`, and the paragraph renders as literal text (no line break, no `|`, no strikethrough)
+
+**Cleanup:** write fixture content back over `{DOC_ID}`
+
+**Result (2026-10-10) ✅ PASS — Kit, PR #968 round 2 (`759362a`).** `get_doc_as_markdown` returned all four expected lines exactly. markdown-it-py 4.2.0 (`commonmark` + `table` + `strikethrough`) rendered the cells `<code>a|*b* _c_</code>`, `<code>C:\|x</code>`, and `<code>x</code><br><a href="https://example.com/b"><code>b</code></a>`, and the paragraph `Use &lt;br&gt; or &amp;#124; and ~~old~~, AT&amp;T a &lt; b`, with no `<em>`, `<del>`, or line break. Fixture content was written back.
+
+---
+
 ## Orphan fileId on inline-image sharing failure (#649)
 
 Mirrors #420's fix in `drive/transfer.py` (see TC-D249/TC-D250 in `docs/qa/tests/drive_transfer.md`) applied to the same create()-succeeds-but-follow-up-fails shape in `docs/images.py`'s `upload_and_share_image` and `docs/content.py`'s `_resolve_image_source`: a transient failure in the `permissions().create()`/`files().get()` sharing step, after `files().create()` (or an already-uploaded `_upload_local_file`) had already succeeded, previously returned a bare `{"error": ...}` with no way to find the Drive file that now genuinely exists. Not reliably reproducible live (would require forcing a transient API failure in the exact window between create and share); verified by unit test instead, matching TC-D249/TC-D250's own convention.

{mcp_gee_sweet-0.9.2.dev286 → mcp_gee_sweet-0.9.2.dev289}/docs/roadmap.md

@@ -192,7 +192,7 @@ Same shape as v0.8.1 — stabilize on defects that surfaced since v0.9.0 shipped
 - [x] `create_paragraph_bullets` (`style.py`) has the same isolated-run collapse-to-`nestingLevel 0` bug #439 fixed in `emitter.py` only — port PR #711's anchor-paragraph approach to the sibling path (PR #723) ([#713](https://github.com/khuisman/mcp-gee-sweet/issues/713))
 - [x] Lock in the isolated-run rendering rule — an isolated bullet run renders at its true depth (`depth N` → `nestingLevel N`) at *every* depth, never clamped (decided 2026-09-09: consistency over avoiding orphaned indent; the markup generator owns the depth it emits). Extend TC-DOC190 with a `min_depth >= 2` case; state the rule in `emitter.py`'s bullet-pass comment and the `docs/emitter.py` paragraph of `CLAUDE.md` (PR #731) ([#714](https://github.com/khuisman/mcp-gee-sweet/issues/714))
 - [x] `create_doc` markdown: a fenced code block whose body is raw HTML tags renders as loose plain paragraphs (fence ignored, indentation flattened) instead of a monospaced code block — python-markdown's raw-HTML-block handling appears to pre-empt `fenced_code`. Surfaced during #714 triage (PR #730) ([#719](https://github.com/khuisman/mcp-gee-sweet/issues/719))
-- [ ] **Bundle:** Docs write side (emitter, html_parser, images, content), one PR closing [#509](https://github.com/khuisman/mcp-gee-sweet/issues/509), [#567](https://github.com/khuisman/mcp-gee-sweet/issues/567), [#581](https://github.com/khuisman/mcp-gee-sweet/issues/581), [#638](https://github.com/khuisman/mcp-gee-sweet/issues/638), [#715](https://github.com/khuisman/mcp-gee-sweet/issues/715) — lane A ([#894](https://github.com/khuisman/mcp-gee-sweet/issues/894))
+- [x] **Bundle:** Docs write side (emitter, html_parser, images, content), one PR closing [#509](https://github.com/khuisman/mcp-gee-sweet/issues/509), [#567](https://github.com/khuisman/mcp-gee-sweet/issues/567), [#581](https://github.com/khuisman/mcp-gee-sweet/issues/581), [#638](https://github.com/khuisman/mcp-gee-sweet/issues/638), [#715](https://github.com/khuisman/mcp-gee-sweet/issues/715) — lane A (PR #961) ([#894](https://github.com/khuisman/mcp-gee-sweet/issues/894))
 - [x] **Bundle:** Calendar hardening, one PR closing [#459](https://github.com/khuisman/mcp-gee-sweet/issues/459), [#615](https://github.com/khuisman/mcp-gee-sweet/issues/615), [#626](https://github.com/khuisman/mcp-gee-sweet/issues/626), [#627](https://github.com/khuisman/mcp-gee-sweet/issues/627), [#726](https://github.com/khuisman/mcp-gee-sweet/issues/726) — lane B (PR #912) ([#890](https://github.com/khuisman/mcp-gee-sweet/issues/890))
 - [x] `delete_file(permanent=True)` surfaces a misleading 404 when the caller can trash but not permanently delete (Shared Drive Content manager) — an agent can read it as "already gone" and skip cleanup; check `capabilities.canDelete` first — lane B ([#876](https://github.com/khuisman/mcp-gee-sweet/issues/876)) (PR #888)
 - [x] SSE: SIGTERM with an SSE stream open logs an "Exception in ASGI application" traceback; the server still exits cleanly, pre-existing before #833 — lane A (PR #911) ([#868](https://github.com/khuisman/mcp-gee-sweet/issues/868))

{mcp_gee_sweet-0.9.2.dev286 → mcp_gee_sweet-0.9.2.dev289}/pyproject.toml

@@ -97,4 +97,5 @@ dev = [
     "pytest-cov>=7.1.0",
     "ruff>=0.16.5",
     "tomli>=2.0.1; python_version < '3.11'",
+    "markdown-it-py>=3.0.0",
 ]

{mcp_gee_sweet-0.9.2.dev286 → mcp_gee_sweet-0.9.2.dev289}/src/mcp_gee_sweet/tools/docs/ast_to_markdown.py

@@ -21,11 +21,21 @@ Known, deliberate gaps (documented rather than silently dropped):
 from __future__ import annotations
 
 import re
+import string
 
 from .ast import BulletItem, Cell, DocNode, Heading, Image, NamedBlock, Paragraph, Run, Table
 from .emitter import _build_phantom_set
 
-_MD_ESCAPE = re.compile(r"([\\`*_\[\]])")
+# Characters in plain text that Markdown would otherwise read as syntax. "~" is
+# GFM strikethrough. "<" only when it could open an HTML tag or autolink, and
+# "&" only when it starts an entity reference, so ordinary prose ("a < b",
+# "AT&T") stays readable. Exported text must not be mistaken for the <br> and
+# <code> HTML the exporter writes itself (#938).
+_MD_ESCAPE = re.compile(
+    r"[\\`*_\[\]~]"
+    r"|<(?=[A-Za-z/!?])"
+    r"|&(?=#[0-9]{1,7};|#[xX][0-9a-fA-F]{1,6};|[A-Za-z][A-Za-z0-9]*;)"
+)
 _BACKTICK_RUN = re.compile(r"`+")
 
 # A paragraph whose rendered text starts with one of these (unescaped) would be
@@ -93,23 +103,16 @@ def _render_code_block(node: Paragraph) -> str:
     Run text did."""
     segments: list[str] = []
     buffer = ""
-
-    def fenced(text: str) -> str:
-        # Literal fences in the content must never close the surrounding block.
-        ticks = max((len(match.group()) for match in _BACKTICK_RUN.finditer(text)), default=0)
-        fence = "`" * max(3, ticks + 1)
-        return f"{fence}\n{text}\n{fence}"
-
     for item in node.runs:
         if isinstance(item, Run):
             buffer += item.text
         else:
             if buffer:
-                segments.append(fenced(buffer))
+                segments.append(_fenced_code_block(buffer))
                 buffer = ""
             segments.append(f"![{_escape(item.alt or '')}]({_md_link_dest(item.src)})")
     if buffer:
-        segments.append(fenced(buffer))
+        segments.append(_fenced_code_block(buffer))
     return "\n\n".join(segments)
 
 
@@ -171,7 +174,7 @@ def _md_link_dest(url: str) -> str:
 
 def _render_inline(items: list[Run | Image]) -> str:
     parts: list[str] = []
-    for item in items:
+    for item in _coalesce_code_runs(items):
         if isinstance(item, Image):
             parts.append(f"![{_escape(item.alt or '')}]({_md_link_dest(item.src)})")
         else:
@@ -179,22 +182,63 @@ def _render_inline(items: list[Run | Image]) -> str:
     return "".join(parts)
 
 
-def _render_run(run: Run) -> str:
+def _is_code_run(item: Run | Image | Table) -> bool:
+    return isinstance(item, Run) and item.font_family == "Courier New"
+
+
+def _coalesce_code_runs(items: list) -> list:
+    """Merge adjacent code runs that share a link. Docs splits a run at any
+    style change (bold, color), but rendered side by side two code spans
+    would read as one: `` `a``b` `` parses as the single span "a``b", since
+    the first span's closing delimiter and the second's opening one form one
+    backtick run. A code span can't carry those styles anyway, so the merge
+    loses nothing. Runs with different links stay apart; the link brackets
+    already separate them."""
+    merged: list = []
+    for item in items:
+        prev = merged[-1] if merged else None
+        if (
+            _is_code_run(item)
+            and prev is not None
+            and _is_code_run(prev)
+            and prev.link_url == item.link_url
+        ):
+            merged[-1] = Run(
+                text=prev.text + item.text, font_family="Courier New", link_url=prev.link_url
+            )
+        else:
+            merged.append(item)
+    return merged
+
+
+def _render_run(run: Run, in_table: bool = False) -> str:
+    """Markdown for one run. `in_table` makes the result safe inside a
+    pipe-table cell (see `_table_safe`)."""
     if run.text == "":
         return ""
     if run.font_family == "Courier New":
-        # Use a delimiter longer than any literal backtick sequence in the
-        # content, and separate edge backticks from that delimiter.
-        ticks = (
-            max((len(match.group()) for match in _BACKTICK_RUN.finditer(run.text)), default=0) + 1
-        )
-        fence = "`" * ticks
-        content = run.text
-        if content.startswith("`") or content.endswith("`"):
-            content = f" {content} "
-        body = f"{fence}{content}{fence}"
-        return f"[{body}]({_md_link_dest(run.link_url)})" if run.link_url else body
+        return _render_code_run(run, in_table)
+    body = _render_plain_run(run)
+    return _table_safe(body) if in_table else body
+
+
+def _render_code_run(run: Run, in_table: bool) -> str:
+    # Line breaks at either end go outside the link, so a cell's paragraph
+    # break (a leading "\n" from doc_to_ast) or a trailing soft break doesn't
+    # render as a <br> inside the <a>.
+    inner = run.text.strip("\n")
+    if not inner:
+        return "<br>" * len(run.text)
+    lead = "<br>" * (len(run.text) - len(run.text.lstrip("\n")))
+    trail = "<br>" * (len(run.text) - len(run.text.rstrip("\n")))
+    body = _render_code_run_text(inner, in_table)
+    if run.link_url:
+        dest = _md_link_dest(run.link_url)
+        body = f"[{body}]({_table_safe(dest) if in_table else dest})"
+    return f"{lead}{body}{trail}"
+
 
+def _render_plain_run(run: Run) -> str:
     # CommonMark emphasis delimiters can't have whitespace on the inner side
     # (e.g. "**Bold **" doesn't close — the space right before "**" means it
     # renders as literal asterisks, not bold). Keep leading/trailing
@@ -220,7 +264,64 @@ def _render_run(run: Run) -> str:
 
 
 def _escape(text: str) -> str:
-    return _MD_ESCAPE.sub(r"\\\1", text)
+    return _MD_ESCAPE.sub(lambda m: "\\" + m.group(), text)
+
+
+def _longest_backtick_run(text: str) -> int:
+    return max((len(match.group()) for match in _BACKTICK_RUN.finditer(text)), default=0)
+
+
+def _fenced_code_block(text: str) -> str:
+    # A fence must be longer than any backtick run in the content, or a
+    # literal ``` line inside the block would close it early.
+    fence = "`" * max(3, _longest_backtick_run(text) + 1)
+    return f"{fence}\n{text}\n{fence}"
+
+
+def _code_span(text: str) -> str:
+    """One CommonMark code span for `text` (which has no newline).
+
+    A code span's content is literal: backslash escapes don't work inside
+    it, so the only tools are the delimiter length and padding. The
+    delimiter is one backtick longer than the longest run in the content, so
+    no literal run can close the span. Padding is exactly one space a side
+    because CommonMark strips exactly one space from each end when both ends
+    have one (and the content isn't all spaces). That stripping is what
+    separates an edge backtick from the delimiter, and it would also eat a
+    real leading and trailing space, so both cases get padded."""
+    fence = "`" * (_longest_backtick_run(text) + 1)
+    pad = text.startswith("`") or text.endswith("`")
+    pad = pad or (text.startswith(" ") and text.endswith(" ") and text.strip(" ") != "")
+    if pad:
+        text = f" {text} "
+    return f"{fence}{text}{fence}"
+
+
+def _render_code_run_text(text: str, in_table: bool) -> str:
+    """Inline code for `text`, which may span lines.
+
+    A code span can't hold a line break: CommonMark turns one into a space,
+    and in a paragraph a raw newline can start a new block (a "# " heading,
+    a "- " item) before the span is parsed. So each line becomes its own
+    span, joined by <br> the same way a table cell joins its lines.
+
+    In a table cell, a "|" splits the cell before inline parsing, and the
+    GFM `\\|` escape inside a code span shows its backslash in renderers
+    that don't implement that rule. A line holding a "|" is written as raw
+    HTML <code> instead, which no table parser splits on. Text inside raw
+    HTML is still parsed as Markdown, so every ASCII punctuation character
+    becomes a numeric entity: an entity is never Markdown syntax, and a
+    backslash can't escape the "&" that starts one."""
+    spans: list[str] = []
+    for line in text.split("\n"):
+        if not line:
+            spans.append("")
+        elif in_table and "|" in line:
+            escaped = "".join(f"&#{ord(c)};" if c in string.punctuation else c for c in line)
+            spans.append(f"<code>{escaped}</code>")
+        else:
+            spans.append(_code_span(line))
+    return "<br>".join(spans)
 
 
 def _render_table(table: Table) -> str:
@@ -249,29 +350,38 @@ def _render_table(table: Table) -> str:
 
 def _render_cell(cell: Cell) -> str:
     parts: list[str] = []
-    for child in cell.children:
+    for child in _coalesce_code_runs(cell.children):
         if isinstance(child, Table):
             parts.append(_NESTED_TABLE_PLACEHOLDER)
         elif isinstance(child, Image):
-            parts.append(f"![{_escape(child.alt or '')}]({_md_link_dest(child.src)})")
+            parts.append(_table_safe(f"![{_escape(child.alt or '')}]({_md_link_dest(child.src)})"))
         else:
-            parts.append(_render_run(child))
-    # Pipe-table cells are single-line: a literal newline (from a multi-
-    # paragraph cell, see doc_to_ast.py's _cell_content_to_children) would
-    # break the table's row structure, so it becomes a <br> instead. "|" is
-    # escaped for the same structural reason.
-    #
-    # \n -> <br> conversion must happen BEFORE strip(), not after (#594 QA
-    # round 2): a spacer paragraph at the very start or end of a cell (as
-    # opposed to one sandwiched between two real lines) shows up here as a
-    # leading/trailing "\n" on the joined text — stripping first, as an
-    # earlier version of this function did, silently ate exactly that
-    # newline, making an edge spacer indistinguishable from a cell with no
-    # spacer at all. "<br>" is not whitespace, so converting first means
-    # strip() only removes genuine incidental whitespace, never a spacer
-    # that's already been turned into a <br> marker.
-    text = "".join(parts).replace("\n", "<br>").replace("|", "\\|")
-    return text.strip()
+            parts.append(_render_run(child, in_table=True))
+    # Every part is already table-safe, with its newlines turned into <br>,
+    # so strip() here only removes incidental whitespace, never an edge
+    # spacer paragraph (#594 QA round 2; see _table_safe).
+    return "".join(parts).strip()
+
+
+def _table_safe(text: str) -> str:
+    """Make rendered non-code Markdown safe inside a pipe-table cell.
+
+    Pipe-table cells are single-line: a literal newline (from a multi-
+    paragraph cell, see doc_to_ast.py's _cell_content_to_children) would
+    break the table's row structure, so it becomes a <br> instead. "|" is
+    escaped for the same structural reason.
+
+    This runs per part, before _render_cell's strip(), not on the joined
+    cell text after it (#594 QA round 2): a spacer paragraph at the very
+    start or end of a cell shows up as a leading/trailing "\\n", and
+    stripping first silently ate exactly that newline. "<br>" is not
+    whitespace, so converting first keeps the spacer.
+
+    Code runs never go through this: _render_code_run_text writes its own
+    <br> and table-safe <code>, and escaping its output again would put a
+    literal backslash inside the code (#938). Only a code link's
+    destination is passed through here."""
+    return text.replace("\n", "<br>").replace("|", "\\|")
 
 
 def _render_comment(comment: dict) -> str:

{mcp_gee_sweet-0.9.2.dev286 → mcp_gee_sweet-0.9.2.dev289}/tests/test_docs_markdown_export.py

@@ -7,6 +7,7 @@ from xml.etree import ElementTree
 
 import markdown
 import pytest
+from markdown_it import MarkdownIt
 
 from mcp_gee_sweet.tools import docs as docs_module
 from mcp_gee_sweet.tools.docs.ast import (
@@ -21,6 +22,16 @@ from mcp_gee_sweet.tools.docs.ast import (
 from mcp_gee_sweet.tools.docs.ast_to_markdown import ast_to_markdown
 from mcp_gee_sweet.tools.docs.doc_to_ast import document_to_ast
 
+# Strict CommonMark, plus GFM pipe tables. Python-Markdown (used by some older
+# tests below) strips whitespace inside code spans and closes a fence only on an
+# exact-length match, so it can't catch padding or fence-length regressions
+# (#938).
+_COMMONMARK = MarkdownIt("commonmark").enable("table")
+
+
+def _code(text, **kwargs):
+    return Run(text=text, font_family="Courier New", **kwargs)
+
 
 @pytest.mark.parametrize("ticks", [3, 4, 6])
 @pytest.mark.parametrize("interleaved_image", [False, True])
@@ -30,12 +41,14 @@ def test_code_block_preserves_literal_backtick_fences(ticks, interleaved_image):
     if interleaved_image:
         runs += [Image(src="https://example.com/image.png"), *runs]
     rendered = ast_to_markdown([Paragraph(runs=runs)])
-    html = markdown.markdown(rendered, extensions=["fenced_code"])
-    root = ElementTree.fromstring(f"<root>{html}</root>")
-    blocks = root.findall("pre/code")
+    assert rendered.startswith("`" * (ticks + 1) + "\nbefore\n")
+    tokens = _COMMONMARK.parse(rendered)
+    blocks = [t.content for t in tokens if t.type == "fence"]
     expected = [content + "\n"] * (2 if interleaved_image else 1)
-    assert [block.text for block in blocks] == expected
-    assert len(root.findall("p/img")) == int(interleaved_image)
+    assert blocks == expected
+    assert sum(t.type == "image" for t in tokens for t in (t.children or [])) == int(
+        interleaved_image
+    )
 
 
 def _para(text, style=None, bullet=None, para_style=None):
@@ -957,3 +970,169 @@ def test_inline_code_backticks_survive_markdown_rendering(text, link_url):
     assert code.text == text
     if link_url:
         assert rendered.find("a").attrib["href"] == link_url
+
+
+def _inline_code(markdown_text):
+    """Each code span's content in the first paragraph, as strict CommonMark parses it."""
+    inline = next(t for t in _COMMONMARK.parse(markdown_text) if t.type == "inline")
+    return [t.content for t in inline.children if t.type == "code_inline"]
+
+
+class TestInlineCodeCommonMark:
+    """#938: code-span edge cases checked against a strict CommonMark parser."""
+
+    @pytest.mark.parametrize(
+        "text",
+        [
+            "call(`value`)",
+            "`leading",
+            "trailing`",
+            "``nested``",
+            " both ends ",
+            " leading only",
+            "trailing only ",
+            "  ",
+            " `x` ",
+            "  double  ",
+        ],
+    )
+    @pytest.mark.parametrize("link_url", [None, "https://example.com/code"])
+    def test_code_span_content_survives_exactly(self, text, link_url):
+        nodes = [Paragraph(runs=[Run(text="see "), _code(text, link_url=link_url), Run(text=".")])]
+        assert _inline_code(ast_to_markdown(nodes)) == [text]
+
+    def test_adjacent_code_runs_merge_into_one_span(self):
+        # Docs splits a run at a style change; Markdown can't show bold code.
+        nodes = [Paragraph(runs=[Run(text="a "), _code("x`"), _code("`y", bold=True)])]
+        assert _inline_code(ast_to_markdown(nodes)) == ["x``y"]
+
+    def test_adjacent_code_runs_with_same_link_merge(self):
+        url = "https://example.com"
+        nodes = [
+            Paragraph(runs=[Run(text="a "), _code("x", link_url=url), _code("y", link_url=url)])
+        ]
+        assert ast_to_markdown(nodes) == f"a [`xy`]({url})\n"
+
+    def test_adjacent_code_runs_with_different_links_stay_separate(self):
+        nodes = [
+            Paragraph(
+                runs=[
+                    Run(text="a "),
+                    _code("x", link_url="https://a.example"),
+                    _code("y", link_url="https://b.example"),
+                    _code("z"),
+                ]
+            )
+        ]
+        assert _inline_code(ast_to_markdown(nodes)) == ["x", "y", "z"]
+
+    def test_code_run_merge_does_not_mutate_input(self):
+        first, second = _code("x"), _code("y")
+        ast_to_markdown([Paragraph(runs=[Run(text="a "), first, second])])
+        assert (first.text, second.text) == ("x", "y")
+
+    def test_newline_in_inline_code_does_not_start_a_new_block(self):
+        nodes = [Paragraph(runs=[Run(text="a "), _code("x\n# y\n- z\n\nw"), Run(text=" b")])]
+        rendered = ast_to_markdown(nodes)
+        tokens = _COMMONMARK.parse(rendered)
+        assert [t.type for t in tokens] == ["paragraph_open", "inline", "paragraph_close"]
+        assert _inline_code(rendered) == ["x", "# y", "- z", "w"]
+        assert rendered == "a `x`<br>`# y`<br>`- z`<br><br>`w` b\n"
+
+    def test_newline_in_inline_code_inside_blockquote_stays_one_line(self):
+        nodes = [Paragraph(runs=[Run(text="a "), _code("x\ny")], blockquote_depth=1)]
+        assert ast_to_markdown(nodes) == "> a `x`<br>`y`\n"
+
+
+class TestTableCellCodeCommonMark:
+    """#938: inline code inside a GFM pipe-table cell."""
+
+    def _render_cell(self, children):
+        from mcp_gee_sweet.tools.docs.ast import Cell, Row
+
+        table = Table(
+            rows=[
+                Row(cells=[Cell(children=[Run(text="h")])]),
+                Row(cells=[Cell(children=children)]),
+            ]
+        )
+        rendered = ast_to_markdown([table])
+        html = _COMMONMARK.render(rendered)
+        return rendered, html[html.index("<td>") + 4 : html.index("</td>")]
+
+    def test_pipe_in_code_has_no_backslash(self):
+        rendered, cell = self._render_cell([_code("a|b")])
+        assert "\\" not in rendered
+        assert cell == "<code>a|b</code>"
+
+    def test_pipe_code_escapes_html_special_characters(self):
+        _, cell = self._render_cell([_code("<a> & b|c")])
+        assert cell == "<code>&lt;a&gt; &amp; b|c</code>"
+
+    def test_code_without_pipe_stays_a_code_span(self):
+        rendered, cell = self._render_cell([_code(" `x` ")])
+        assert "| ``  `x`  `` |" in rendered
+        assert cell == "<code> `x` </code>"
+
+    def test_newline_in_code_becomes_br_outside_the_code(self):
+        _, cell = self._render_cell([Run(text="t "), _code("x\ny")])
+        assert cell == "t <code>x</code><br><code>y</code>"
+
+    def test_code_paragraphs_in_one_cell_join_with_br(self):
+        # doc_to_ast prefixes the second paragraph's first run with "\n".
+        _, cell = self._render_cell([_code("x"), _code("\ny|z")])
+        assert cell == "<code>x</code><br><code>y|z</code>"
+
+    def test_plain_pipe_next_to_code_is_still_escaped(self):
+        _, cell = self._render_cell([Run(text="a|b "), _code("c")])
+        assert cell == "a|b <code>c</code>"
+
+    def test_linked_code_with_pipe_in_url_stays_in_one_cell(self):
+        rendered, cell = self._render_cell([_code("c", link_url="https://e.example/a|b")])
+        assert rendered.splitlines()[2].count("|") - rendered.splitlines()[2].count("\\|") == 2
+        assert cell == '<a href="https://e.example/a%7Cb"><code>c</code></a>'
+
+    def test_pipe_code_keeps_markdown_punctuation_literal(self):
+        # Text inside raw <code> is still parsed as Markdown (PR #968 QA round 1).
+        text = "a|*b* _c_ [x](y) ~~d~~ `e` <i> &amp;"
+        _, cell = self._render_cell([_code(text)])
+        assert cell == "<code>a|*b* _c_ [x](y) ~~d~~ `e` &lt;i&gt; &amp;amp;</code>"
+
+    def test_backslash_before_pipe_in_code_survives(self):
+        _, cell = self._render_cell([_code("C:\\|x")])
+        assert cell == "<code>C:\\|x</code>"
+
+    def test_linked_code_paragraph_break_lands_outside_the_link(self):
+        url = "https://e.example"
+        _, cell = self._render_cell([_code("x"), _code("\nb", link_url=url)])
+        assert cell == f'<code>x</code><br><a href="{url}"><code>b</code></a>'
+
+    def test_plain_run_rendered_in_table_is_table_safe(self):
+        from mcp_gee_sweet.tools.docs.ast_to_markdown import _render_run
+
+        assert _render_run(Run(text="a|b\nc"), in_table=True) == "a\\|b<br>c"
+
+
+class TestPlainTextEscapingCommonMark:
+    """PR #968 QA round 1: plain text that looks like HTML, an entity, or GFM
+    strikethrough must export as literal text."""
+
+    def test_html_entity_and_tilde_render_literally(self):
+        text = "Use <br> or &#124; and &amp; and ~~old~~ </p> <!-- x -->"
+        rendered = ast_to_markdown([Paragraph(runs=[Run(text=text)])])
+        inline = next(t for t in _COMMONMARK.parse(rendered) if t.type == "inline")
+        assert [t.type for t in inline.children] == ["text"]
+        assert inline.children[0].content == text
+
+    def test_prose_ampersand_and_less_than_stay_unescaped(self):
+        rendered = ast_to_markdown([Paragraph(runs=[Run(text="AT&T: a < b & c")])])
+        assert rendered == "AT&T: a < b & c\n"
+
+    def test_linked_code_trailing_soft_break_lands_outside_the_link(self):
+        url = "https://e.example"
+        nodes = [Paragraph(runs=[Run(text="a "), _code("x\n", link_url=url), Run(text="b")])]
+        rendered = ast_to_markdown(nodes)
+        assert rendered == f"a [`x`]({url})<br>b\n"
+        assert _COMMONMARK.render(rendered) == (
+            f'<p>a <a href="{url}"><code>x</code></a><br>b</p>\n'
+        )