fix(changelog): preserve fenced code blocks in custom PR changelog entries

Code blocks (```lang ... ```) in custom Changelog Entry sections of PR
descriptions were silently dropped during parsing.

Root cause: two functions only handled a subset of marked.lexer token types:

1. extractNestedContent() only handled 'list' tokens — code blocks inside
   list items were skipped
2. parseTokensToEntries() only handled 'list' and 'paragraph' — standalone
   code blocks after paragraphs were skipped

Fix: add 'code' token handling to both functions:
- In extractNestedContent: render as indented fenced code block (2-space
  indent, matching sub-bullet level), properly handled during recursive
  indentation for deeper nesting
- In parseTokensToEntries: attach standalone code blocks as nestedContent
  on the previous entry, or create a new entry if no previous one exists

Author: BYK

src/utils/__tests__/changelog-extract.test.ts

@@ -197,3 +197,96 @@ Intro paragraph:
     });
   });
 });
+
+describe('extractChangelogEntry code blocks', () => {
+  it('preserves fenced code block inside a bullet item', () => {
+    const prBody = `### Changelog Entry
+
+- Added a new \`foo\` function:
+  \`\`\`go
+  func foo() {
+    fmt.Println("Hello")
+  }
+  \`\`\`
+- Another entry`;
+
+    const result = extractChangelogEntry(prBody);
+    expect(result).toHaveLength(2);
+    expect(result![0].text).toBe('Added a new `foo` function:');
+    expect(result![0].nestedContent).toContain('```go');
+    expect(result![0].nestedContent).toContain('func foo()');
+    expect(result![1].text).toBe('Another entry');
+    expect(result![1].nestedContent).toBeUndefined();
+  });
+
+  it('preserves code block without language specifier', () => {
+    const prBody = `### Changelog Entry
+
+- Example code:
+  \`\`\`
+  some code here
+  \`\`\``;
+
+    const result = extractChangelogEntry(prBody);
+    expect(result).toHaveLength(1);
+    expect(result![0].text).toBe('Example code:');
+    expect(result![0].nestedContent).toContain('```');
+    expect(result![0].nestedContent).toContain('some code here');
+    // Should not have a language tag after the opening fence
+    expect(result![0].nestedContent).not.toMatch(/```\S/);
+  });
+
+  it('preserves standalone code block after paragraph', () => {
+    const prBody = `### Changelog Entry
+
+Here is a change with code:
+
+\`\`\`go
+func foo() {}
+\`\`\``;
+
+    const result = extractChangelogEntry(prBody);
+    expect(result).toHaveLength(1);
+    expect(result![0].text).toBe('Here is a change with code:');
+    expect(result![0].nestedContent).toContain('```go');
+    expect(result![0].nestedContent).toContain('func foo() {}');
+    // Verify 2-space indentation for proper nesting under list items
+    expect(result![0].nestedContent).toBe('  ```go\n  func foo() {}\n  ```');
+  });
+
+  it('preserves code block in loose list item', () => {
+    const prBody = `### Changelog Entry
+
+- First entry with code:
+
+  \`\`\`go
+  func foo() {}
+  \`\`\`
+
+- Second entry`;
+
+    const result = extractChangelogEntry(prBody);
+    expect(result).toHaveLength(2);
+    expect(result![0].text).toBe('First entry with code:');
+    expect(result![0].nestedContent).toContain('```go');
+    expect(result![0].nestedContent).toContain('func foo() {}');
+    expect(result![1].text).toBe('Second entry');
+  });
+
+  it('preserves nested list items alongside code blocks', () => {
+    const prBody = `### Changelog Entry
+
+- Main entry
+  - Sub item
+  \`\`\`js
+  const x = 1;
+  \`\`\``;
+
+    const result = extractChangelogEntry(prBody);
+    expect(result).toHaveLength(1);
+    expect(result![0].text).toBe('Main entry');
+    expect(result![0].nestedContent).toContain('- Sub item');
+    expect(result![0].nestedContent).toContain('```js');
+    expect(result![0].nestedContent).toContain('const x = 1;');
+  });
+});

src/utils/changelog.ts

@@ -337,6 +337,15 @@ function extractNestedContent(tokens: Token[]): string {
           nestedLines.push(indentedDeeper);
         }
       }
+    } else if (token.type === 'code') {
+      // Preserve fenced code blocks (e.g., ```go ... ```) as nested content
+      const codeToken = token as Tokens.Code;
+      const fence = codeToken.lang ? `\`\`\`${codeToken.lang}` : '```';
+      nestedLines.push(`  ${fence}`);
+      for (const line of codeToken.text.split('\n')) {
+        nestedLines.push(`  ${line}`);
+      }
+      nestedLines.push('  ```');
     }
   }
 
@@ -390,6 +399,30 @@ function parseTokensToEntries(tokens: Token[]): ChangelogEntryItem[] | null {
       if (text) {
         entries.push({ text });
       }
+    } else if (token.type === 'code') {
+      // Standalone code blocks become nested content on the previous entry,
+      // or a new entry if there is no previous entry.
+      // Indent with 2 spaces so the block nests properly under the list item
+      // in the final markdown (consistent with extractNestedContent).
+      const codeToken = token as Tokens.Code;
+      const fence = codeToken.lang ? `\`\`\`${codeToken.lang}` : '```';
+      const indentedLines = [`  ${fence}`];
+      for (const line of codeToken.text.split('\n')) {
+        indentedLines.push(`  ${line}`);
+      }
+      indentedLines.push('  ```');
+      const codeBlock = indentedLines.join('\n');
+
+      if (entries.length > 0) {
+        // Attach to previous entry as nested content
+        const prev = entries[entries.length - 1];
+        prev.nestedContent = prev.nestedContent
+          ? `${prev.nestedContent}\n${codeBlock}`
+          : codeBlock;
+      } else {
+        // No previous entry - create one with the code block as content
+        entries.push({ text: '', nestedContent: codeBlock });
+      }
     }
   }