Render a code patch whose opening fence ends a prose line

packages/host/app/lib/matrix-classes/message.ts

@@ -6,6 +6,7 @@ import { TrackedArray } from 'tracked-built-ins';
 import { escapeHtmlOutsideCodeBlocks } from '@cardstack/runtime-common/helpers/html';
 import {
   markdownToHtml,
+  splitCodePatchFencesGluedToProse,
   widenFencesAroundCodePatches,
 } from '@cardstack/runtime-common/marked-sync';
 
@@ -233,7 +234,11 @@ export class Message implements RoomMessageInterface {
       return this.body;
     }
     return markdownToHtml(
-      widenFencesAroundCodePatches(escapeHtmlOutsideCodeBlocks(this.body)!),
+      widenFencesAroundCodePatches(
+        splitCodePatchFencesGluedToProse(
+          escapeHtmlOutsideCodeBlocks(this.body)!,
+        ),
+      ),
       {
         sanitize: false,
         escapeHtmlInCodeBlocks: true,

packages/host/tests/unit/marked-sync-test.ts

@@ -9,6 +9,7 @@ import { escapeHtmlOutsideCodeBlocks } from '@cardstack/runtime-common/helpers/h
 import {
   markedSync,
   markdownToHtml,
+  splitCodePatchFencesGluedToProse,
   widenFencesAroundCodePatches,
 } from '@cardstack/runtime-common/marked-sync';
 
@@ -20,7 +21,9 @@ import { parseHtmlContent } from '@cardstack/host/lib/formatted-message/utils';
 // the applier matches it against the target file.
 function renderBodyToCodeData(body: string) {
   let html = markdownToHtml(
-    widenFencesAroundCodePatches(escapeHtmlOutsideCodeBlocks(body)!),
+    widenFencesAroundCodePatches(
+      splitCodePatchFencesGluedToProse(escapeHtmlOutsideCodeBlocks(body)!),
+    ),
     {
       sanitize: false,
       escapeHtmlInCodeBlocks: true,
@@ -67,6 +70,69 @@ ${REPLACE_MARKER}
 `;
 
 module('Unit | marked-sync', function () {
+  test('a patch whose opening fence ends a prose line still renders as a code block', function (assert) {
+    // The renderer opens a fence only at the start of a line, so a patch that
+    // begins "Let's write the block!```json" is prose to it: no code block,
+    // nothing applied, and the bot waits for a result that never comes.
+    let body = `I'll create the theme now. Let's write the block!\`\`\`json
+https://example.com/realm/moon-theme.json (new)
+${SEARCH_MARKER}
+${SEPARATOR_MARKER}
+{ "data": { "type": "card" } }
+${REPLACE_MARKER}
+\`\`\`
+`;
+    let blocks = renderBodyToCodeData(body);
+
+    assert.deepEqual(
+      blocks.map((b) => b.fileUrl),
+      ['https://example.com/realm/moon-theme.json'],
+      'the patch is found with its url on the first line',
+    );
+    assert.true(
+      blocks[0].searchReplaceBlock!.includes('{ "data": { "type": "card" } }'),
+      'the file content survives',
+    );
+  });
+
+  test('splitCodePatchFencesGluedToProse moves only the fence to its own line', function (assert) {
+    let body = `Let's write the block!\`\`\`json
+https://example.com/realm/a.json (new)
+${SEARCH_MARKER}
+${SEPARATOR_MARKER}
+{}
+${REPLACE_MARKER}
+\`\`\`
+`;
+    assert.strictEqual(
+      splitCodePatchFencesGluedToProse(body),
+      `Let's write the block!\n\`\`\`json\n` +
+        body.split('\n').slice(1).join('\n'),
+    );
+  });
+
+  test('splitCodePatchFencesGluedToProse leaves prose that ends in backticks alone', function (assert) {
+    let inlineCode = 'Use the helper ```\nnot a patch\nsome more text\n';
+    assert.strictEqual(
+      splitCodePatchFencesGluedToProse(inlineCode),
+      inlineCode,
+    );
+
+    let properFence = `\`\`\`json
+https://example.com/realm/a.json (new)
+${SEARCH_MARKER}
+${SEPARATOR_MARKER}
+{}
+${REPLACE_MARKER}
+\`\`\`
+`;
+    assert.strictEqual(
+      splitCodePatchFencesGluedToProse(properFence),
+      properFence,
+      'a fence already on its own line is unchanged',
+    );
+  });
+
   test('a patch that writes markdown with fenced code inside renders as one block, and the patch after it keeps its url', function (assert) {
     // Without widening, the first bare ``` inside the plan closes the patch's
     // fence; the fence meant to close the patch then opens a block that

packages/runtime-common/marked-sync.ts

@@ -157,6 +157,35 @@ function normalizeDecorativeBullets(markdown: string): string {
 // partially received plan file already renders as one block.
 const FILE_URL_LINE_PATTERN = /^\s*https?:\/\/\S+(\s*\(\s*new\s*\))?\s*\r?$/;
 
+// A fence opens a code block only at the start of a line. A model that ends a
+// sentence and starts the patch on the same line — "Let's write the block!```json"
+// — has written a patch the renderer reads as prose: the url, the markers and
+// the file content collapse into one paragraph, the host finds no code block
+// and applies nothing, and the bot, which counts patches by their markers,
+// waits for a result that never comes. The block itself is correct; only the
+// line break before the fence is missing. Put it back when the two lines after
+// the fence are a file url and the SEARCH marker, which is what makes this a
+// patch rather than prose that happens to end in backticks.
+const FENCE_GLUED_TO_PROSE_PATTERN = /^(.*\S)(`{3,}\w*)\s*(\r?)$/;
+
+export function splitCodePatchFencesGluedToProse(markdown: string): string {
+  let lines = markdown.split('\n');
+  for (let i = 0; i + 2 < lines.length; i++) {
+    let glued = lines[i].match(FENCE_GLUED_TO_PROSE_PATTERN);
+    if (
+      glued &&
+      !CODE_FENCE_PATTERN.test(lines[i]) &&
+      FILE_URL_LINE_PATTERN.test(lines[i + 1]) &&
+      SEARCH_MARKER_PATTERN.test(lines[i + 2])
+    ) {
+      let [, prose, fence, cr] = glued;
+      lines.splice(i, 1, `${prose}${cr}`, `${fence}${cr}`);
+      i++;
+    }
+  }
+  return lines.join('\n');
+}
+
 export function widenFencesAroundCodePatches(markdown: string): string {
   let lines = markdown.split('\n');
   let i = 0;