markrender 1.1.1__tar.gz → 1.2.0__tar.gz

markrender-1.2.0/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+All notable changes to MarkRender are documented here.
+
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and the project uses [Semantic Versioning](https://semver.org/). Releases are
+cut from conventional commits, and new entries are added by the publish
+workflow when a release goes out.
+
+## [1.1.1] - 2026-10-30
+
+### Fixed
+
+- Dim mode now renders the whole response in one uniform muted gray, including paragraphs, lists, tables, quotes, and code blocks.
+
+### Documentation
+
+- Clarified the CLI and Python usage examples.
+
+## [1.1.0] - 2026-10-30
+
+### Added
+
+- Dim mode for streaming responses, enabled per render call.
+- Theme previews in the README and a `preview-themes` command.
+- `--width`, `--force-color`, and `--version` CLI flags.
+- TOML config file support with warnings for unknown keys.
+- Dynamic code block line-number widths.
+- Better handling of split stream chunks and buffer boundaries.
+
+### Changed
+
+- Rewrote the README around CLI and Python usage instead of feature marketing.
+- Dim mode moved from the constructor to a `render()` argument.
+- Themes are now deep-copied so rendering cannot mutate shared theme state.
+- Improved the parser regexes for bold + italic, inline code, links, and blockquotes.
+
+### Fixed
+
+- Blockquotes falling through to other block handlers.
+- Dictionary themes loaded from TOML files failing to render.
+- Table overflow when content is wider than the terminal.
+- Encoding fallback when the output stream is not UTF-8.
+- Config files now warn about unknown keys instead of failing silently.
+
+Releases before 1.1.0 were published before this changelog existed.

{markrender-1.1.1/markrender.egg-info → markrender-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markrender
-Version: 1.1.1
+Version: 1.2.0
 Summary: Professional terminal markdown renderer for streaming LLM responses
 Author: Praneeth Gandodi
 License: MIT
@@ -422,6 +422,11 @@ Hello :wave: Let's :rocket: go!
 - **Note-Taking Apps** - Terminal-based markdown note viewers
 - **Log Viewers** - Render structured logs with markdown
 
+## Changelog
+
+Release notes come from conventional commit messages, so the history stays in
+one place. See [CHANGELOG.md](CHANGELOG.md) for what changed in each version.
+
 ## Development
 
 ### Setup Development Environment
@@ -458,12 +463,19 @@ no version number to edit by hand.
 2. Choose `auto` (recommended) or an explicit `patch`, `minor`, or `major` bump.
 3. The workflow runs the tests, creates the next `vX.Y.Z` tag, builds the
    sdist and wheel, publishes to PyPI, and creates a GitHub release.
+4. Release notes are generated from the commits since the last tag, and the
+   same entry is added to [CHANGELOG.md](CHANGELOG.md) on `main`.
 
 With `auto`, commit messages since the last tag decide the bump:
 
 - `feat!:` or a `BREAKING CHANGE:` footer → major
 - `feat:` → minor
-- everything else → patch
+- `fix:`, `perf:`, `refactor:`, or `revert:` → patch
+- `docs:`, `test:`, `chore:`, `ci:`, `build:`, and `style:` don't trigger a
+  release on their own
+
+Write commit subjects in the `type(scope): summary` form so the changelog and
+version bump stay accurate.
 
 Publishing uses PyPI Trusted Publishing (OIDC), so no API token is stored in
 the repository. Configure it once:

{markrender-1.1.1 → markrender-1.2.0}/README.md

@@ -390,6 +390,11 @@ Hello :wave: Let's :rocket: go!
 - **Note-Taking Apps** - Terminal-based markdown note viewers
 - **Log Viewers** - Render structured logs with markdown
 
+## Changelog
+
+Release notes come from conventional commit messages, so the history stays in
+one place. See [CHANGELOG.md](CHANGELOG.md) for what changed in each version.
+
 ## Development
 
 ### Setup Development Environment
@@ -426,12 +431,19 @@ no version number to edit by hand.
 2. Choose `auto` (recommended) or an explicit `patch`, `minor`, or `major` bump.
 3. The workflow runs the tests, creates the next `vX.Y.Z` tag, builds the
    sdist and wheel, publishes to PyPI, and creates a GitHub release.
+4. Release notes are generated from the commits since the last tag, and the
+   same entry is added to [CHANGELOG.md](CHANGELOG.md) on `main`.
 
 With `auto`, commit messages since the last tag decide the bump:
 
 - `feat!:` or a `BREAKING CHANGE:` footer → major
 - `feat:` → minor
-- everything else → patch
+- `fix:`, `perf:`, `refactor:`, or `revert:` → patch
+- `docs:`, `test:`, `chore:`, `ci:`, `build:`, and `style:` don't trigger a
+  release on their own
+
+Write commit subjects in the `type(scope): summary` form so the changelog and
+version bump stay accurate.
 
 Publishing uses PyPI Trusted Publishing (OIDC), so no API token is stored in
 the repository. Configure it once:

{markrender-1.1.1 → markrender-1.2.0}/markrender/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.1.1'
-__version_tuple__ = version_tuple = (1, 1, 1)
+__version__ = version = '1.2.0'
+__version_tuple__ = version_tuple = (1, 2, 0)
 
 __commit_id__ = commit_id = None

{markrender-1.1.1 → markrender-1.2.0}/markrender/formatters.py

@@ -3,7 +3,6 @@ Output formatters for markdown elements
 Handles rendering of headings, code, tables, lists, and more
 """
 
-import re
 from pygments import highlight
 from pygments.lexers import get_lexer_by_name, TextLexer
 from pygments.formatters import Terminal256Formatter
@@ -12,7 +11,7 @@ try:
 except ImportError:
     emoji_lib = None
 
-from .colors import colorize, Colors, get_terminal_width
+from .colors import colorize, strip_ansi, Colors, get_terminal_width
 
 
 class MarkdownFormatter:
@@ -135,7 +134,31 @@ class MarkdownFormatter:
         """
         return self._colorize(f'`{text}`', self.inline_code_color)
     
-    def format_table(self, rows):
+    @staticmethod
+    def _visible_width(text):
+        """Return the printable width of text, ignoring ANSI escapes."""
+        return len(strip_ansi(str(text)))
+
+    @staticmethod
+    def _fit_table_widths(widths, available):
+        """Keep short columns intact and share the loss across long ones."""
+        widths = list(widths)
+        if sum(widths) <= available:
+            return widths
+
+        fitted = [0] * len(widths)
+        remaining = available
+        remaining_cols = len(widths)
+
+        for index in sorted(range(len(widths)), key=widths.__getitem__):
+            share = max(1, remaining // remaining_cols)
+            fitted[index] = min(widths[index], share)
+            remaining -= fitted[index]
+            remaining_cols -= 1
+
+        return fitted
+
+    def format_table(self, rows, alignments=None):
         if not rows:
             return ''
 
@@ -149,21 +172,15 @@ class MarkdownFormatter:
         col_widths = [0] * max_cols
         for row in normalized_rows:
             for i, cell in enumerate(row):
-                clean_cell = re.sub(r'\033\[[0-9;]*m', '', str(cell))
-                col_widths[i] = max(col_widths[i], len(clean_cell))
+                col_widths[i] = max(col_widths[i], self._visible_width(cell))
 
         total_border_chars = max_cols * 3 + 1
-        total_table_width = sum(col_widths) + total_border_chars
-        max_width = self.width - 2
+        available = self.width - 2 - total_border_chars
+        available = max(available, max_cols)
+        col_widths = self._fit_table_widths(col_widths, available)
 
-        if total_table_width > max_width:
-            available = max_width - total_border_chars
-            widths_sum = sum(col_widths)
-            if available < max_cols:
-                col_widths = [max(1, available // max_cols)] * max_cols
-            else:
-                for i in range(max_cols):
-                    col_widths[i] = max(1, col_widths[i] * available // widths_sum)
+        alignments = list(alignments or [])
+        alignments += ['left'] * (max_cols - len(alignments))
 
         border_color = self.theme['table_border']
         header_color = self.theme.get('table_header')
@@ -172,18 +189,33 @@ class MarkdownFormatter:
         for row_idx, row in enumerate(normalized_rows):
             padded = []
             for i, cell in enumerate(row):
-                clean_cell = re.sub(r'\033\[[0-9;]*m', '', str(cell))
-                if len(clean_cell) > col_widths[i]:
-                    cell_str = clean_cell[:col_widths[i] - 1] + '…'
-                    if row_idx == 0 and header_color:
-                        cell_str = self._colorize(cell_str, header_color + Colors.BOLD)
+                clean_cell = strip_ansi(str(cell))
+                width = col_widths[i]
+
+                if self._visible_width(clean_cell) > width:
+                    if width > 1:
+                        cell_str = clean_cell[:width - 1] + '…'
+                    else:
+                        cell_str = '…'
                 else:
                     cell_str = str(cell)
-                    padding = col_widths[i] - len(clean_cell)
-                    if padding:
-                        cell_str = cell_str + ' ' * padding
-                    if row_idx == 0 and header_color:
-                        cell_str = self._colorize(cell_str, header_color + Colors.BOLD)
+
+                padding = width - self._visible_width(cell_str)
+                alignment = alignments[i]
+                if alignment == 'right':
+                    cell_str = ' ' * padding + cell_str
+                elif alignment == 'center':
+                    left = padding // 2
+                    cell_str = (
+                        ' ' * left + cell_str + ' ' * (padding - left)
+                    )
+                else:
+                    cell_str = cell_str + ' ' * padding
+
+                if row_idx == 0 and header_color:
+                    cell_str = self._colorize(
+                        cell_str, header_color + Colors.BOLD
+                    )
                 padded.append(cell_str)
 
             cells_formatted = [f' {cell} ' for cell in padded]

{markrender-1.1.1 → markrender-1.2.0}/markrender/parser.py

@@ -78,6 +78,22 @@ class MarkdownParser:
     def is_separator_row(cells):
         return bool(cells and all(re.match(r"^:?-+:?$", cell) for cell in cells))
 
+    @staticmethod
+    def parse_table_alignments(cells):
+        """Return the alignment for each column from a separator row."""
+        alignments = []
+        for cell in cells:
+            cell = cell.strip()
+            left = cell.startswith(':')
+            right = cell.endswith(':')
+            if left and right:
+                alignments.append('center')
+            elif right:
+                alignments.append('right')
+            else:
+                alignments.append('left')
+        return alignments
+
     def parse_checkbox(self, line):
         match = self.CHECKBOX_PATTERN.match(line)
         if match:

{markrender-1.1.1 → markrender-1.2.0}/markrender/renderer.py

@@ -23,6 +23,7 @@ class RenderState:
         self.in_table = False
         self.table_rows = []
         self.table_row_count = 0
+        self.table_alignments = []
         self.in_blockquote = False
         self.blockquote_lines = []
         self.alert_type: Optional[str] = None
@@ -38,6 +39,7 @@ class RenderState:
         self.in_table = False
         self.table_rows = []
         self.table_row_count = 0
+        self.table_alignments = []
 
     def reset_blockquote(self):
         self.in_blockquote = False
@@ -227,12 +229,16 @@ class MarkdownRenderer:
             stripped = line.rstrip()
             table_row = self.parser.parse_table_row(stripped)
             if table_row is not None:
-                if not self.parser.is_separator_row(table_row):
+                if self.parser.is_separator_row(table_row):
+                    self.state.table_alignments = self.parser.parse_table_alignments(table_row)
+                else:
                     formatted_row = [self.parser.apply_inline_formatting(cell, self.formatter) for cell in table_row]
                     self.state.table_rows.append(formatted_row)
             else:
                 if self.state.table_rows:
-                    formatted = self.formatter.format_table(self.state.table_rows)
+                    formatted = self.formatter.format_table(
+                        self.state.table_rows, self.state.table_alignments
+                    )
                     self._write(formatted, 'table')
                 self.state.reset_table()
                 self.buffer = self._rebuild_buffer(complete_lines[i:], tail)
@@ -294,12 +300,17 @@ class MarkdownRenderer:
             if not self.state.in_table:
                 self.state.in_table = True
                 self.state.table_rows = []
-            if not self.parser.is_separator_row(table_row):
+                self.state.table_alignments = []
+            if self.parser.is_separator_row(table_row):
+                self.state.table_alignments = self.parser.parse_table_alignments(table_row)
+            else:
                 formatted_row = [self.parser.apply_inline_formatting(cell, self.formatter) for cell in table_row]
                 self.state.table_rows.append(formatted_row)
             return
         elif self.state.in_table:
-            formatted = self.formatter.format_table(self.state.table_rows)
+            formatted = self.formatter.format_table(
+                self.state.table_rows, self.state.table_alignments
+            )
             self._write(formatted, 'table')
             self.state.reset_table()
 
@@ -383,7 +394,9 @@ class MarkdownRenderer:
             self.state.reset_code()
 
         if self.state.in_table and self.state.table_rows:
-            formatted = self.formatter.format_table(self.state.table_rows)
+            formatted = self.formatter.format_table(
+                self.state.table_rows, self.state.table_alignments
+            )
             self._write(formatted, 'table')
             self.state.reset_table()
 

{markrender-1.1.1 → markrender-1.2.0/markrender.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markrender
-Version: 1.1.1
+Version: 1.2.0
 Summary: Professional terminal markdown renderer for streaming LLM responses
 Author: Praneeth Gandodi
 License: MIT
@@ -422,6 +422,11 @@ Hello :wave: Let's :rocket: go!
 - **Note-Taking Apps** - Terminal-based markdown note viewers
 - **Log Viewers** - Render structured logs with markdown
 
+## Changelog
+
+Release notes come from conventional commit messages, so the history stays in
+one place. See [CHANGELOG.md](CHANGELOG.md) for what changed in each version.
+
 ## Development
 
 ### Setup Development Environment
@@ -458,12 +463,19 @@ no version number to edit by hand.
 2. Choose `auto` (recommended) or an explicit `patch`, `minor`, or `major` bump.
 3. The workflow runs the tests, creates the next `vX.Y.Z` tag, builds the
    sdist and wheel, publishes to PyPI, and creates a GitHub release.
+4. Release notes are generated from the commits since the last tag, and the
+   same entry is added to [CHANGELOG.md](CHANGELOG.md) on `main`.
 
 With `auto`, commit messages since the last tag decide the bump:
 
 - `feat!:` or a `BREAKING CHANGE:` footer → major
 - `feat:` → minor
-- everything else → patch
+- `fix:`, `perf:`, `refactor:`, or `revert:` → patch
+- `docs:`, `test:`, `chore:`, `ci:`, `build:`, and `style:` don't trigger a
+  release on their own
+
+Write commit subjects in the `type(scope): summary` form so the changelog and
+version bump stay accurate.
 
 Publishing uses PyPI Trusted Publishing (OIDC), so no API token is stored in
 the repository. Configure it once:

{markrender-1.1.1 → markrender-1.2.0}/markrender.egg-info/SOURCES.txt

@@ -1,4 +1,5 @@
 .gitignore
+CHANGELOG.md
 LICENSE
 MANIFEST.in
 README.md
@@ -36,6 +37,7 @@ markrender.egg-info/entry_points.txt
 markrender.egg-info/requires.txt
 markrender.egg-info/scm_file_list.json
 markrender.egg-info/top_level.txt
+tests/test_changelog.py
 tests/test_colors.py
 tests/test_dim_mode.py
 tests/test_formatters.py

{markrender-1.1.1 → markrender-1.2.0}/markrender.egg-info/scm_file_list.json

@@ -1,9 +1,11 @@
 {
   "files": [
+    ".github/scripts/changelog.py",
     ".github/scripts/next_version.py",
     ".github/workflows/ci.yml",
     ".github/workflows/publish.yml",
     ".gitignore",
+    "CHANGELOG.md",
     "LICENSE",
     "MANIFEST.in",
     "README.md",
@@ -33,6 +35,7 @@
     "requirements.txt",
     "setup.py",
     "test.md",
+    "tests/test_changelog.py",
     "tests/test_colors.py",
     "tests/test_dim_mode.py",
     "tests/test_formatters.py",

markrender-1.2.0/tests/test_changelog.py

@@ -0,0 +1,150 @@
+"""Tests for the changelog helper used by the publish workflow."""
+
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+SCRIPT = REPO_ROOT / ".github" / "scripts" / "changelog.py"
+
+pytestmark = pytest.mark.skipif(
+    not SCRIPT.exists(), reason="release helper is not part of this checkout"
+)
+
+
+def git(repo, *args):
+    subprocess.run(
+        ["git", *args],
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+
+def commit(repo, message, filename):
+    (repo / filename).write_text(filename, encoding="utf-8")
+    git(repo, "add", filename)
+    git(repo, "commit", "-m", message)
+
+
+def run_changelog(repo, *args):
+    return subprocess.run(
+        [sys.executable, str(SCRIPT), *args],
+        cwd=repo,
+        capture_output=True,
+        text=True,
+    )
+
+
+def make_repo(path):
+    git(path, "init", "-q")
+    git(path, "config", "user.email", "test@example.com")
+    git(path, "config", "user.name", "Test")
+    commit(path, "feat: initial release", "initial.txt")
+    git(path, "tag", "-a", "v1.1.0", "-m", "v1.1.0")
+    commit(path, "feat(renderer): add table alignment", "table.txt")
+    commit(path, "fix: stop crushing short columns", "fit.txt")
+    commit(path, "docs: mention the changelog", "readme.txt")
+    commit(path, "chore: tidy up", "chore.txt")
+    commit(path, "test: cover narrow tables", "test.txt")
+    return path
+
+
+def test_entry_groups_conventional_commits(tmp_path):
+    repo = make_repo(tmp_path)
+
+    result = run_changelog(
+        repo, "--version", "1.1.1", "--tag", "v1.1.1", "--date", "2026-10-30"
+    )
+
+    assert result.returncode == 0
+    assert "## [1.1.1] - 2026-10-30" in result.stdout
+    assert "### Added" in result.stdout
+    assert "**renderer:** Add table alignment" in result.stdout
+    assert "### Fixed" in result.stdout
+    assert "Stop crushing short columns" in result.stdout
+    assert "### Documentation" in result.stdout
+    assert "Tidy up" not in result.stdout
+    assert "Cover narrow tables" not in result.stdout
+
+
+def test_notes_file_omits_the_version_heading(tmp_path):
+    repo = make_repo(tmp_path)
+    notes = repo / "notes.md"
+
+    result = run_changelog(
+        repo,
+        "--version",
+        "1.1.1",
+        "--tag",
+        "v1.1.1",
+        "--date",
+        "2026-10-30",
+        "--notes-file",
+        str(notes),
+    )
+
+    assert result.returncode == 0
+    body = notes.read_text(encoding="utf-8")
+    assert "## [1.1.1]" not in body
+    assert "### Added" in body
+
+
+def test_write_inserts_above_the_newest_release(tmp_path):
+    repo = make_repo(tmp_path)
+    changelog = repo / "CHANGELOG.md"
+    changelog.write_text(
+        "# Changelog\n\n"
+        "## [1.1.0] - 2026-10-01\n\n"
+        "### Added\n\n- Initial release.\n",
+        encoding="utf-8",
+    )
+
+    result = run_changelog(
+        repo,
+        "--version",
+        "1.1.1",
+        "--tag",
+        "v1.1.1",
+        "--date",
+        "2026-10-30",
+        "--write",
+        str(changelog),
+    )
+
+    assert result.returncode == 0
+    text = changelog.read_text(encoding="utf-8")
+    assert text.index("## [1.1.1]") < text.index("## [1.1.0]")
+    assert text.startswith("# Changelog")
+
+
+def test_write_is_idempotent(tmp_path):
+    repo = make_repo(tmp_path)
+    changelog = repo / "CHANGELOG.md"
+    changelog.write_text("# Changelog\n", encoding="utf-8")
+
+    args = ("--version", "1.1.1", "--tag", "v1.1.1", "--write", str(changelog))
+    run_changelog(repo, *args)
+    first = changelog.read_text(encoding="utf-8")
+    run_changelog(repo, *args)
+
+    assert changelog.read_text(encoding="utf-8") == first
+    assert first.count("## [1.1.1]") == 1
+
+
+def test_release_with_only_maintenance_commits(tmp_path):
+    repo = tmp_path
+    git(repo, "init", "-q")
+    git(repo, "config", "user.email", "test@example.com")
+    git(repo, "config", "user.name", "Test")
+    commit(repo, "feat: initial release", "initial.txt")
+    git(repo, "tag", "-a", "v1.1.0", "-m", "v1.1.0")
+    commit(repo, "chore: tidy up", "chore.txt")
+
+    result = run_changelog(repo, "--version", "1.1.1", "--tag", "v1.1.1")
+
+    assert result.returncode == 0
+    assert "No user-facing changes" in result.stdout

{markrender-1.1.1 → markrender-1.2.0}/tests/test_formatters.py

@@ -367,3 +367,18 @@ class TestMarkdownFormatter:
         """Test strikethrough formatting"""
         result = self.formatter.format_strikethrough("strike")
         assert "strike" in result
+
+
+class TestTableAlignment:
+    """Column alignment in formatted tables."""
+
+    def test_format_table_alignment(self):
+        formatter = MarkdownFormatter(get_theme('github-dark'), width=80)
+        rows = [
+            ["Name", "Qty", "Status"],
+            ["A", "2", "ok"],
+        ]
+
+        result = formatter.format_table(rows, ["left", "right", "center"])
+
+        assert "│ A    │   2 │   ok   │" in result

{markrender-1.1.1 → markrender-1.2.0}/tests/test_parser.py

@@ -309,3 +309,21 @@ class TestMarkdownParser:
         assert result == ""
 
 
+
+
+class TestTableAlignments:
+    """Alignment markers on table separator rows."""
+
+    def test_parse_table_alignments(self):
+        parser = MarkdownParser()
+        cells = parser.parse_table_row("|:---|:---:|---:|")
+
+        assert parser.parse_table_alignments(cells) == [
+            "left", "center", "right"
+        ]
+
+    def test_parse_table_alignments_defaults_to_left(self):
+        parser = MarkdownParser()
+        cells = parser.parse_table_row("|---|---|")
+
+        assert parser.parse_table_alignments(cells) == ["left", "left"]

{markrender-1.1.1 → markrender-1.2.0}/tests/test_renderer.py

@@ -620,3 +620,62 @@ class TestMarkdownRenderer:
         result = output.getvalue()
         assert "A" in result
         assert "code" in result
+
+
+class TestTableAlignment:
+    """Table alignment and width handling through the renderer."""
+
+    def test_alignment_markers_are_rendered(self):
+        output = StringIO()
+        renderer = MarkdownRenderer(output=output)
+
+        renderer.render("| Item | Qty | Price |\n")
+        renderer.render("|:-----|----:|------:|\n")
+        renderer.render("| Apples | 3 | 1.20 |\n")
+        renderer.render("\n")
+        renderer.finalize()
+
+        assert "│ Apples │   3 │  1.20 │" in output.getvalue()
+
+    def test_short_columns_keep_their_text(self):
+        output = StringIO()
+        renderer = MarkdownRenderer(output=output, width=60)
+
+        renderer.render("| Name | Description | Status |\n")
+        renderer.render("|---|---|---|\n")
+        renderer.render(
+            "| markrender | Render markdown in the terminal with "
+            "streaming support and syntax highlighting | active |\n"
+        )
+        renderer.render("\n")
+        renderer.finalize()
+
+        result = output.getvalue()
+        assert "markrender" in result
+        assert "Status" in result
+        assert "markre…" not in result
+        assert "Stat…" not in result
+
+    def test_narrow_table_does_not_crush_a_single_column(self):
+        output = StringIO()
+        renderer = MarkdownRenderer(output=output, width=34)
+
+        renderer.render("| Name | Description | Status |\n")
+        renderer.render("|---|---|---|\n")
+        renderer.render(
+            "| markrender | Render markdown in the terminal with "
+            "streaming support and syntax highlighting | active |\n"
+        )
+        renderer.render("\n")
+        renderer.finalize()
+
+        lines = [
+            line for line in output.getvalue().splitlines()
+            if line.startswith("┌")
+        ]
+        widths = [
+            len(segment) for segment in lines[0][1:-1].split("┬")
+        ]
+
+        assert max(widths) - min(widths) <= 2
+        assert all(len(line) <= 34 for line in output.getvalue().splitlines())

{markrender-1.1.1 → markrender-1.2.0}/tests/test_versioning.py

@@ -77,6 +77,35 @@ def test_feature_commit_bumps_minor(tmp_path):
     assert result.stdout.strip() == "1.1.0"
 
 
+def test_docs_only_commit_does_not_release(tmp_path):
+    repo = make_repo(tmp_path)
+    commit(repo, "docs: explain the width flag", "readme.txt")
+
+    result = next_version(repo, "--bump", "auto")
+
+    assert result.returncode == 3
+
+
+def test_chore_only_commit_does_not_release(tmp_path):
+    repo = make_repo(tmp_path)
+    commit(repo, "chore: remove a local harness", "chore.txt")
+
+    result = next_version(repo, "--bump", "auto")
+
+    assert result.returncode == 3
+
+
+def test_maintenance_commits_do_not_raise_the_bump(tmp_path):
+    repo = make_repo(tmp_path)
+    commit(repo, "feat: add a renderer option", "feature.txt")
+    commit(repo, "chore: tidy up", "chore.txt")
+
+    result = next_version(repo, "--bump", "auto")
+
+    assert result.returncode == 0
+    assert result.stdout.strip() == "1.1.0"
+
+
 def test_breaking_commit_bumps_major(tmp_path):
     repo = make_repo(tmp_path)
     commit(repo, "feat!: change the public API", "breaking.txt")