flowmark 0.2.1__tar.gz → 0.3.0__tar.gz

flowmark-0.3.0/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.3
+Name: flowmark
+Version: 0.3.0
+Summary: Better line wrapping and formatting for plaintext and Markdown
+License: MIT
+Author: Joshua Levy
+Author-email: joshua@cal.berkeley.edu
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: marko (>=2.1.2,<3.0.0)
+Requires-Dist: regex (>=2024.11.6,<2025.0.0)
+Requires-Dist: strif (>=2.0.0,<3.0.0)
+Description-Content-Type: text/markdown
+
+# flowmark
+
+Flowmark is a new Python implementation of **text and Markdown line wrapping and
+filling**.
+
+In addition, it adds optional **support for Markdown** and offers **Markdown
+auto-formatting and normalization**. This is much like
+[markdownfmt](https://github.com/shurcooL/markdownfmt) or
+[prettier's Markdown support](https://prettier.io/blog/2017/11/07/1.8.0) but is pure
+Python and has (in my humble opinion) better options and defaults.
+
+Use cases:
+
+- As a **command line formatter** to format text or Markdown files using the `flowmark`
+  command.
+
+- To **autoformat Markdown on save in VSCode/Cursor** or any other editor that supports
+  running a command on save.
+  Flowmark uses a readable format that makes diffs easy to read and use on GitHub.
+  It also normalizes all Markdown syntax variations (such as different header or
+  formatting styles). This can be especially useful for documentation and editing
+  workflows where clean diffs and minimal merge conflicts on GitHub are important.
+
+- As a **library to autoformat Markdown**. For example, it is great to normalize the
+  outputs from LLMs to be consistent, or to run on the inputs and outputs of LLM
+  transformations that edit text, so that the resulting diffs are clean.
+  Having this as a simple Python library makes this easy in AI-related document
+  pipelines.
+
+- As a **drop-in replacement library for Python's default
+  [`textwrap`](https://docs.python.org/3/library/textwrap.html)** but with more options.
+  It simplifies and generalizes that library, offering better control over **initial and
+  subsequent indentation** and **when to split words and lines**, e.g. using a word
+  splitter that won't break lines within HTML tags.
+
+- Flowmark has the option to to use **semantic line breaks** (using a heuristic to break
+  lines on sentences sentences when that is reasonable), which is an underrated feature
+  that can **make diffs on GitHub much more readable**. The the change may seem subtle
+  but avoids having paragraphs reflow for very small edits, which does a lot to
+  **minimize merge conflicts**. An example of what sentence-guided wrapping looks like,
+  see the
+  [Markdown source](https://github.com/jlevy/flowmark/blob/main/README.md?plain=1) of
+  this readme file.)
+
+- Very, very simple and fast **regex-based sentence splitting**. This should work fine
+  for English and many other latin/Cyrillic languages but it hasn't been tested on CJK.
+
+It aims to be small and simple and have only a few dependencies, currently only
+[`marko`](https://github.com/frostming/marko),
+[`regex`](https://pypi.org/project/regex/), and
+[`strif`](https://github.com/jlevy/strif).
+
+Because **YAML frontmatter** is common on Markdown files, the Markdown autoformat
+preserves all frontmatter (content between `---` delimiters at the front of a file).
+
+This is a new and simple package.
+Previously I'd implemented something very similar with
+[for Atom](https://github.com/jlevy/atom-flowmark) but Atom is no more and there seems
+to be greater need for this in Python now.
+From many years experience, I found the Markdown formatting conventions enforced by the
+Atom Flowmark plugin worked well for editing and publishing large or collaboratively
+edited documents.
+
+## Installation
+
+The simplest way to use the tool is to use [pipx](https://github.com/pypa/pipx):
+
+```shell
+pipx install flowmark
+```
+
+Then
+
+```
+flowmark --help
+```
+
+To use as a library, use pip/poetry/uv to install
+[`flowmark`](https://pypi.org/project/flowmark/).
+
+## Use in VSCode/Cursor
+
+You can use Flowmark to auto-format Markdown on save in VSCode or Cursor.
+Install the "Run on Save" (`emeraldwalk.runonsave`) extension.
+Then add to your `settings.json`:
+
+```json
+  "emeraldwalk.runonsave": {
+    "commands": [
+        {
+            "match": "\\.md$",
+            "cmd": "flowmark --auto ${file}"
+        }
+    ]
+  }
+```
+
+The `--auto` option is just the same as `--inplace --nobackup --semantic`.
+
+## Usage
+
+Flowmark can be used as a library or as a CLI.
+
+```
+$ flowmark --help
+usage: flowmark [-h] [-o OUTPUT] [-w WIDTH] [-p] [-s] [-i] [--nobackup] [file]
+
+Flowmark: Better line wrapping and formatting for plaintext and Markdown
+
+positional arguments:
+  file                 Input file (use '-' for stdin)
+
+options:
+  -h, --help           show this help message and exit
+  -o, --output OUTPUT  Output file (use '-' for stdout)
+  -w, --width WIDTH    Line width to wrap to
+  -p, --plaintext      Process as plaintext (no Markdown parsing)
+  -s, --semantic       Enable sentence-based line breaks (only applies to Markdown mode)
+  -i, --inplace        Edit the file in place (ignores --output)
+  --nobackup           Do not make a backup of the original file when using --inplace
+
+Flowmark provides enhanced text wrapping capabilities with special handling for
+Markdown content. It can:
+
+- Format Markdown with proper line wrapping while preserving structure
+  and normalizing Markdown formatting
+
+- Optionally break lines at sentence boundaries for better diff readability
+
+- Process plaintext with HTML-aware word splitting
+
+It is both a library and a command-line tool.
+
+Command-line usage examples:
+
+  # Format a Markdown file to stdout
+  flowmark README.md
+
+  # Format a Markdown file and save to a new file
+  flowmark README.md -o README_formatted.md
+
+  # Edit a file in-place (with or without making a backup)
+  flowmark --inplace README.md
+  flowmark --inplace --nobackup README.md
+
+  # Process plaintext instead of Markdown
+  flowmark --plaintext text.txt
+
+  # Use sentences to guide line breaks (good for many purposes git history and diffs)
+  flowmark --semantic README.md
+
+For more details, see: https://github.com/jlevy/flowmark
+```
+
+* * *
+
+*This project was built from
+[simple-modern-poetry](https://github.com/jlevy/simple-modern-poetry).*
+

flowmark-0.3.0/README.md

@@ -0,0 +1,158 @@
+# flowmark
+
+Flowmark is a new Python implementation of **text and Markdown line wrapping and
+filling**.
+
+In addition, it adds optional **support for Markdown** and offers **Markdown
+auto-formatting and normalization**. This is much like
+[markdownfmt](https://github.com/shurcooL/markdownfmt) or
+[prettier's Markdown support](https://prettier.io/blog/2017/11/07/1.8.0) but is pure
+Python and has (in my humble opinion) better options and defaults.
+
+Use cases:
+
+- As a **command line formatter** to format text or Markdown files using the `flowmark`
+  command.
+
+- To **autoformat Markdown on save in VSCode/Cursor** or any other editor that supports
+  running a command on save.
+  Flowmark uses a readable format that makes diffs easy to read and use on GitHub.
+  It also normalizes all Markdown syntax variations (such as different header or
+  formatting styles). This can be especially useful for documentation and editing
+  workflows where clean diffs and minimal merge conflicts on GitHub are important.
+
+- As a **library to autoformat Markdown**. For example, it is great to normalize the
+  outputs from LLMs to be consistent, or to run on the inputs and outputs of LLM
+  transformations that edit text, so that the resulting diffs are clean.
+  Having this as a simple Python library makes this easy in AI-related document
+  pipelines.
+
+- As a **drop-in replacement library for Python's default
+  [`textwrap`](https://docs.python.org/3/library/textwrap.html)** but with more options.
+  It simplifies and generalizes that library, offering better control over **initial and
+  subsequent indentation** and **when to split words and lines**, e.g. using a word
+  splitter that won't break lines within HTML tags.
+
+- Flowmark has the option to to use **semantic line breaks** (using a heuristic to break
+  lines on sentences sentences when that is reasonable), which is an underrated feature
+  that can **make diffs on GitHub much more readable**. The the change may seem subtle
+  but avoids having paragraphs reflow for very small edits, which does a lot to
+  **minimize merge conflicts**. An example of what sentence-guided wrapping looks like,
+  see the
+  [Markdown source](https://github.com/jlevy/flowmark/blob/main/README.md?plain=1) of
+  this readme file.)
+
+- Very, very simple and fast **regex-based sentence splitting**. This should work fine
+  for English and many other latin/Cyrillic languages but it hasn't been tested on CJK.
+
+It aims to be small and simple and have only a few dependencies, currently only
+[`marko`](https://github.com/frostming/marko),
+[`regex`](https://pypi.org/project/regex/), and
+[`strif`](https://github.com/jlevy/strif).
+
+Because **YAML frontmatter** is common on Markdown files, the Markdown autoformat
+preserves all frontmatter (content between `---` delimiters at the front of a file).
+
+This is a new and simple package.
+Previously I'd implemented something very similar with
+[for Atom](https://github.com/jlevy/atom-flowmark) but Atom is no more and there seems
+to be greater need for this in Python now.
+From many years experience, I found the Markdown formatting conventions enforced by the
+Atom Flowmark plugin worked well for editing and publishing large or collaboratively
+edited documents.
+
+## Installation
+
+The simplest way to use the tool is to use [pipx](https://github.com/pypa/pipx):
+
+```shell
+pipx install flowmark
+```
+
+Then
+
+```
+flowmark --help
+```
+
+To use as a library, use pip/poetry/uv to install
+[`flowmark`](https://pypi.org/project/flowmark/).
+
+## Use in VSCode/Cursor
+
+You can use Flowmark to auto-format Markdown on save in VSCode or Cursor.
+Install the "Run on Save" (`emeraldwalk.runonsave`) extension.
+Then add to your `settings.json`:
+
+```json
+  "emeraldwalk.runonsave": {
+    "commands": [
+        {
+            "match": "\\.md$",
+            "cmd": "flowmark --auto ${file}"
+        }
+    ]
+  }
+```
+
+The `--auto` option is just the same as `--inplace --nobackup --semantic`.
+
+## Usage
+
+Flowmark can be used as a library or as a CLI.
+
+```
+$ flowmark --help
+usage: flowmark [-h] [-o OUTPUT] [-w WIDTH] [-p] [-s] [-i] [--nobackup] [file]
+
+Flowmark: Better line wrapping and formatting for plaintext and Markdown
+
+positional arguments:
+  file                 Input file (use '-' for stdin)
+
+options:
+  -h, --help           show this help message and exit
+  -o, --output OUTPUT  Output file (use '-' for stdout)
+  -w, --width WIDTH    Line width to wrap to
+  -p, --plaintext      Process as plaintext (no Markdown parsing)
+  -s, --semantic       Enable sentence-based line breaks (only applies to Markdown mode)
+  -i, --inplace        Edit the file in place (ignores --output)
+  --nobackup           Do not make a backup of the original file when using --inplace
+
+Flowmark provides enhanced text wrapping capabilities with special handling for
+Markdown content. It can:
+
+- Format Markdown with proper line wrapping while preserving structure
+  and normalizing Markdown formatting
+
+- Optionally break lines at sentence boundaries for better diff readability
+
+- Process plaintext with HTML-aware word splitting
+
+It is both a library and a command-line tool.
+
+Command-line usage examples:
+
+  # Format a Markdown file to stdout
+  flowmark README.md
+
+  # Format a Markdown file and save to a new file
+  flowmark README.md -o README_formatted.md
+
+  # Edit a file in-place (with or without making a backup)
+  flowmark --inplace README.md
+  flowmark --inplace --nobackup README.md
+
+  # Process plaintext instead of Markdown
+  flowmark --plaintext text.txt
+
+  # Use sentences to guide line breaks (good for many purposes git history and diffs)
+  flowmark --semantic README.md
+
+For more details, see: https://github.com/jlevy/flowmark
+```
+
+* * *
+
+*This project was built from
+[simple-modern-poetry](https://github.com/jlevy/simple-modern-poetry).*

{flowmark-0.2.1 → flowmark-0.3.0}/pyproject.toml

@@ -8,7 +8,7 @@ readme = "README.md"
 license = "MIT"
 requires-python = ">=3.10,<4.0"
 dynamic = [ "dependencies", ]
-version = "0.2.1"
+version = "0.3.0"
 
 [tool.poetry]
 requires-poetry = ">=2.0"
@@ -88,7 +88,7 @@ disable_error_code = [
 
 [tool.codespell]
 # ignore-words-list = "foo,bar"
-# skip = "foo.py,bar.py"
+skip = "tests/testdocs/*.md"
 
 [tool.pytest.ini_options]
 python_files = ["*.py"]

{flowmark-0.2.1 → flowmark-0.3.0}/src/flowmark/cli.py

@@ -29,8 +29,9 @@ Command-line usage examples:
   # Process plaintext instead of Markdown
   flowmark --plaintext text.txt
 
-  # Use sentences to guide line breaks (good for many purposes git history and diffs)
-  flowmark --sentences README.md
+  # Use semantic line breaks (based on sentences, which is helpful to reduce
+  # irrelevant line wrap diffs in git history)
+  flowmark --semantic README.md
 
 For more details, see: https://github.com/jlevy/flowmark
 """
@@ -53,7 +54,7 @@ class Options:
     output: str
     width: int
     plaintext: bool
-    sentences: bool
+    semantic: bool
     inplace: bool
     nobackup: bool
 
@@ -91,10 +92,10 @@ def _parse_args(args: Optional[List[str]] = None) -> Options:
     )
     parser.add_argument(
         "-s",
-        "--sentences",
+        "--semantic",
         action="store_true",
         default=False,
-        help="Enable sentence-based line breaks (only applies to Markdown mode)",
+        help="Enable semantic (sentence-based) line breaks (only applies to Markdown mode)",
     )
     parser.add_argument(
         "-i", "--inplace", action="store_true", help="Edit the file in place (ignores --output)"
@@ -107,21 +108,21 @@ def _parse_args(args: Optional[List[str]] = None) -> Options:
     parser.add_argument(
         "--auto",
         action="store_true",
-        help="Same as `--inplace --nobackup --sentences`, as a convenience for auto-formatting files",
+        help="Same as `--inplace --nobackup --semantic`, as a convenience for auto-formatting files",
     )
     opts = parser.parse_args(args)
 
     if opts.auto:
         opts.inplace = True
         opts.nobackup = True
-        opts.sentences = True
+        opts.semantic = True
 
     return Options(
         file=opts.file,
         output=opts.output,
         width=opts.width,
         plaintext=opts.plaintext,
-        sentences=opts.sentences,
+        semantic=opts.semantic,
         inplace=opts.inplace,
         nobackup=opts.nobackup,
     )
@@ -159,7 +160,7 @@ def main(args: Optional[List[str]] = None) -> int:
         result = fill_markdown(
             text,
             width=options.width,
-            by_sentence=options.sentences,
+            semantic=options.semantic,
             dedent_input=True,
         )
 

flowmark-0.3.0/src/flowmark/frontmatter.py

@@ -0,0 +1,44 @@
+from typing import Tuple
+
+
+def split_frontmatter(text: str) -> Tuple[str, str]:
+    """
+    Split a text document into frontmatter and content parts.
+
+    Checks if the string starts with YAML frontmatter, delimited by `---`
+    lines. If so, returns the frontmatter, including the `---` lines, and the
+    rest of the document. If no frontmatter is found, returns an empty string
+    and the original text.
+    """
+    lines = text.splitlines()
+
+    # Skip empty lines at the beginning
+    start_idx = 0
+    while start_idx < len(lines) and lines[start_idx].strip() == "":
+        start_idx += 1
+
+    # If no content or doesn't start with '---', return empty frontmatter
+    if start_idx >= len(lines) or lines[start_idx].strip() != "---":
+        return "", text
+
+    # Look for the closing '---'
+    end_idx = start_idx + 1
+    while end_idx < len(lines):
+        if lines[end_idx].strip() == "---":
+            # Found the closing delimiter - extract frontmatter and content
+            frontmatter = "\n".join(lines[start_idx : end_idx + 1]) + "\n"
+            content = "\n".join(lines[end_idx + 1 :])
+            return frontmatter, content
+        end_idx += 1
+
+    # If no closing delimiter found, everything is considered frontmatter
+    # and nothing should change
+    return text, ""
+
+
+def has_frontmatter(text: str) -> bool:
+    """
+    Check if the text starts with YAML frontmatter.
+    """
+    frontmatter, _ = split_frontmatter(text)
+    return frontmatter != ""

{flowmark-0.2.1 → flowmark-0.3.0}/src/flowmark/markdown_filling.py

@@ -20,6 +20,7 @@ from marko.parser import Parser
 from marko.renderer import Renderer
 from marko.source import Source
 
+from flowmark.frontmatter import split_frontmatter
 from flowmark.line_wrappers import line_wrap_by_sentence, line_wrap_to_width, LineWrapper
 from flowmark.sentence_split_regex import split_sentences_regex
 from flowmark.text_filling import DEFAULT_WRAP_WIDTH
@@ -127,16 +128,33 @@ class _MarkdownNormalizer(Renderer):
         self._prefix = self._second_prefix
         return wrapped_text + "\n"
 
+    def _has_multiple_paragraphs(self, item: object) -> bool:
+        """
+        Check if a list item contains multiple paragraphs.
+        """
+        list_item = cast(block.ListItem, item)
+        paragraphs = [c for c in list_item.children if isinstance(c, block.Paragraph)]
+        return len(paragraphs) > 1
+
     def render_list(self, element: block.List) -> str:
         result: List[str] = []
-        if element.ordered:
-            for num, child in enumerate(element.children, element.start):
-                with self.container(f"{num}. ", " " * (len(str(num)) + 2)):
-                    result.append(self.render(child))
-        else:
-            for child in element.children:
-                with self.container(f"{element.bullet} ", "  "):
-                    result.append(self.render(child))
+
+        for i, child in enumerate(element.children):
+            # Configure the appropriate prefix based on list type
+            if element.ordered:
+                num = i + element.start
+                prefix = f"{num}. "
+                subsequent_indent = " " * (len(str(num)) + 2)
+            else:
+                prefix = f"{element.bullet} "
+                subsequent_indent = "  "
+
+            with self.container(prefix, subsequent_indent):
+                # Add an extra newline before multi-paragraph list items (except the first)
+                if i > 0 and self._has_multiple_paragraphs(child):
+                    result.append(self._second_prefix.strip() + "\n")
+
+                result.append(self.render(child))
 
         self._prefix = self._second_prefix
         return "".join(result)
@@ -150,6 +168,7 @@ class _MarkdownNormalizer(Renderer):
             # Add the newline between paragraphs. Normally this would be an empty line but
             # within a quote block it would be the secondary prefix, like `> `.
             result += self._second_prefix.strip() + "\n"
+
         result += self.render_children(element)
         return result
 
@@ -271,7 +290,7 @@ def fill_markdown(
     markdown_text: str,
     dedent_input: bool = True,
     width: int = DEFAULT_WRAP_WIDTH,
-    by_sentence: bool = False,
+    semantic: bool = False,
     line_wrapper: Optional[LineWrapper] = None,
 ) -> str:
     """
@@ -285,12 +304,25 @@ def fill_markdown(
 
     Optionally also dedents and strips the input, so it can be used
     on docstrings.
+
+    With `semantic` enabled, the line breaks are wrapped approximately
+    by sentence boundaries, to make diffs more readable.
+
+    Preserves YAML frontmatter (delimited by --- lines) if present at the
+    beginning of the document.
     """
     if line_wrapper is None:
         line_wrapper = (
-            line_wrap_by_sentence(width=width) if by_sentence else line_wrap_to_width(width=width)
+            line_wrap_by_sentence(width=width) if semantic else line_wrap_to_width(width=width)
         )
 
+    # Extract frontmatter before any processing
+    frontmatter, content = split_frontmatter(markdown_text)
+
+    # Only format the content part if there's frontmatter
+    if frontmatter:
+        markdown_text = content
+
     if dedent_input:
         markdown_text = dedent(markdown_text).strip()
 
@@ -303,4 +335,9 @@ def fill_markdown(
     parser = CustomParser()
     parsed = parser.parse(markdown_text)
     result = _MarkdownNormalizer(line_wrapper).render(parsed)
+
+    # Reattach frontmatter if it was present
+    if frontmatter:
+        result = frontmatter + result
+
     return result

flowmark-0.2.1/PKG-INFO

@@ -1,142 +0,0 @@
-Metadata-Version: 2.3
-Name: flowmark
-Version: 0.2.1
-Summary: Better line wrapping and formatting for plaintext and Markdown
-License: MIT
-Author: Joshua Levy
-Author-email: joshua@cal.berkeley.edu
-Requires-Python: >=3.10,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: marko (>=2.1.2,<3.0.0)
-Requires-Dist: regex (>=2024.11.6,<2025.0.0)
-Requires-Dist: strif (>=2.0.0,<3.0.0)
-Description-Content-Type: text/markdown
-
-# flowmark
-
-Flowmark is a new Python implementation of text line wrapping and filling.
-
-It simplifies and generalizes Python's
-[`textwrap`](https://docs.python.org/3/library/textwrap.html) with a few more
-capabilities:
-
-- Full customizability of initial and subsequent indentation strings
-
-- Control over when to split words, by default using a word splitter that won't break
-  lines within HTML tags
-
-In addition, it adds optional support for Markdown and offers Markdown auto-formatting,
-like [markdownfmt](https://github.com/shurcooL/markdownfmt), also with controllable line
-wrapping options.
-
-One key use case is to normalize Markdown in a standard, readable way that makes diffs
-easy to read and use on GitHub.
-This can be useful for documentation workflows and also to compare LLM outputs that are
-Markdown.
-
-Finally, it has options to use heuristics to split on sentences, which can make diffs
-much more readable. (For an example of this, look at the
-[Markdown source](https://github.com/jlevy/flowmark/blob/main/README.md?plain=1) of this
-readme file.)
-
-It aims to be small and simple and have only a few dependencies, currently only
-[`marko`](https://github.com/frostming/marko) and
-[`regex`](https://pypi.org/project/regex/).
-
-This is a new and simple package (previously I'd implemented something like this
-[for Atom](https://github.com/jlevy/atom-flowmark)) but I plan to add more support for
-command line usage and VSCode/Cursor auto-formatting in the future.
-
-## Installation
-
-The simplest way to use the tool is to use [pipx](https://github.com/pypa/pipx):
-
-```shell
-pipx install flowmark
-```
-
-To use as a library, use pip or poetry to install `flowmark`.
-
-## Use in VSCode/Cursor
-
-You can use Flowmark to auto-format Markdown on save in VSCode or Cursor. Install
-the "Run on Save" (`emeraldwalk.runonsave`) extension. Then add to your `settings.json`:
-
-```json
-  "emeraldwalk.runonsave": {
-    "commands": [
-        {
-            "match": "\\.md$",
-            "cmd": "flowmark --auto ${file}"
-        }
-    ]
-  }
-```
-
-The `--auto` option is just the same as `--inplace --nobackup --sentences`.
-
-## Usage
-
-Flowmark can be used as a library or as a CLI.
-
-```
-$ flowmark --help
-usage: flowmark [-h] [-o OUTPUT] [-w WIDTH] [-p] [-s] [-i] [--nobackup] [file]
-
-Flowmark: Better line wrapping and formatting for plaintext and Markdown
-
-positional arguments:
-  file                 Input file (use '-' for stdin)
-
-options:
-  -h, --help           show this help message and exit
-  -o, --output OUTPUT  Output file (use '-' for stdout)
-  -w, --width WIDTH    Line width to wrap to
-  -p, --plaintext      Process as plaintext (no Markdown parsing)
-  -s, --sentences      Enable sentence-based line breaks (only applies to Markdown mode)
-  -i, --inplace        Edit the file in place (ignores --output)
-  --nobackup           Do not make a backup of the original file when using --inplace
-
-Flowmark provides enhanced text wrapping capabilities with special handling for
-Markdown content. It can:
-
-- Format Markdown with proper line wrapping while preserving structure
-  and normalizing Markdown formatting
-
-- Optionally break lines at sentence boundaries for better diff readability
-
-- Process plaintext with HTML-aware word splitting
-
-It is both a library and a command-line tool.
-
-Command-line usage examples:
-
-  # Format a Markdown file to stdout
-  flowmark README.md
-
-  # Format a Markdown file and save to a new file
-  flowmark README.md -o README_formatted.md
-
-  # Edit a file in-place (with or without making a backup)
-  flowmark --inplace README.md
-  flowmark --inplace --nobackup README.md
-
-  # Process plaintext instead of Markdown
-  flowmark --plaintext text.txt
-
-  # Use sentences to guide line breaks (good for many purposes git history and diffs)
-  flowmark --sentences README.md
-
-For more details, see: https://github.com/jlevy/flowmark
-```
-
-* * *
-
-*This project was built from
-[simple-modern-poetry](https://github.com/jlevy/simple-modern-poetry).*
-

flowmark-0.2.1/README.md

@@ -1,122 +0,0 @@
-# flowmark
-
-Flowmark is a new Python implementation of text line wrapping and filling.
-
-It simplifies and generalizes Python's
-[`textwrap`](https://docs.python.org/3/library/textwrap.html) with a few more
-capabilities:
-
-- Full customizability of initial and subsequent indentation strings
-
-- Control over when to split words, by default using a word splitter that won't break
-  lines within HTML tags
-
-In addition, it adds optional support for Markdown and offers Markdown auto-formatting,
-like [markdownfmt](https://github.com/shurcooL/markdownfmt), also with controllable line
-wrapping options.
-
-One key use case is to normalize Markdown in a standard, readable way that makes diffs
-easy to read and use on GitHub.
-This can be useful for documentation workflows and also to compare LLM outputs that are
-Markdown.
-
-Finally, it has options to use heuristics to split on sentences, which can make diffs
-much more readable. (For an example of this, look at the
-[Markdown source](https://github.com/jlevy/flowmark/blob/main/README.md?plain=1) of this
-readme file.)
-
-It aims to be small and simple and have only a few dependencies, currently only
-[`marko`](https://github.com/frostming/marko) and
-[`regex`](https://pypi.org/project/regex/).
-
-This is a new and simple package (previously I'd implemented something like this
-[for Atom](https://github.com/jlevy/atom-flowmark)) but I plan to add more support for
-command line usage and VSCode/Cursor auto-formatting in the future.
-
-## Installation
-
-The simplest way to use the tool is to use [pipx](https://github.com/pypa/pipx):
-
-```shell
-pipx install flowmark
-```
-
-To use as a library, use pip or poetry to install `flowmark`.
-
-## Use in VSCode/Cursor
-
-You can use Flowmark to auto-format Markdown on save in VSCode or Cursor. Install
-the "Run on Save" (`emeraldwalk.runonsave`) extension. Then add to your `settings.json`:
-
-```json
-  "emeraldwalk.runonsave": {
-    "commands": [
-        {
-            "match": "\\.md$",
-            "cmd": "flowmark --auto ${file}"
-        }
-    ]
-  }
-```
-
-The `--auto` option is just the same as `--inplace --nobackup --sentences`.
-
-## Usage
-
-Flowmark can be used as a library or as a CLI.
-
-```
-$ flowmark --help
-usage: flowmark [-h] [-o OUTPUT] [-w WIDTH] [-p] [-s] [-i] [--nobackup] [file]
-
-Flowmark: Better line wrapping and formatting for plaintext and Markdown
-
-positional arguments:
-  file                 Input file (use '-' for stdin)
-
-options:
-  -h, --help           show this help message and exit
-  -o, --output OUTPUT  Output file (use '-' for stdout)
-  -w, --width WIDTH    Line width to wrap to
-  -p, --plaintext      Process as plaintext (no Markdown parsing)
-  -s, --sentences      Enable sentence-based line breaks (only applies to Markdown mode)
-  -i, --inplace        Edit the file in place (ignores --output)
-  --nobackup           Do not make a backup of the original file when using --inplace
-
-Flowmark provides enhanced text wrapping capabilities with special handling for
-Markdown content. It can:
-
-- Format Markdown with proper line wrapping while preserving structure
-  and normalizing Markdown formatting
-
-- Optionally break lines at sentence boundaries for better diff readability
-
-- Process plaintext with HTML-aware word splitting
-
-It is both a library and a command-line tool.
-
-Command-line usage examples:
-
-  # Format a Markdown file to stdout
-  flowmark README.md
-
-  # Format a Markdown file and save to a new file
-  flowmark README.md -o README_formatted.md
-
-  # Edit a file in-place (with or without making a backup)
-  flowmark --inplace README.md
-  flowmark --inplace --nobackup README.md
-
-  # Process plaintext instead of Markdown
-  flowmark --plaintext text.txt
-
-  # Use sentences to guide line breaks (good for many purposes git history and diffs)
-  flowmark --sentences README.md
-
-For more details, see: https://github.com/jlevy/flowmark
-```
-
-* * *
-
-*This project was built from
-[simple-modern-poetry](https://github.com/jlevy/simple-modern-poetry).*