linkedown 0.1.0__tar.gz

linkedown-0.1.0/.gitignore

@@ -0,0 +1,22 @@
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+.Python
+*.egg-info/
+dist/
+build/
+.eggs/
+.env
+.venv
+venv/
+*.egg
+.installed.cfg
+*.dist-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+htmlcov/
+.coverage
+*.cover
+.hypothesis/

linkedown-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gregory R. Warnes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

linkedown-0.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: linkedown
+Version: 0.1.0
+Summary: Bidirectional Markdown ↔ LinkedIn Unicode converter. CLI and MCP tools.
+Project-URL: Homepage, https://github.com/Warnes-Innovations/linkedown
+Project-URL: Repository, https://github.com/Warnes-Innovations/linkedown
+Project-URL: Issues, https://github.com/Warnes-Innovations/linkedown/issues
+Author-email: "Gregory R. Warnes" <greg@warnes-innovations.com>
+License: MIT
+License-File: LICENSE
+Keywords: cli,converter,linkedin,markdown,mcp,unicode
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: click>=8.0
+Requires-Dist: mcp>=1.0
+Requires-Dist: mistune>=3.0
+Requires-Dist: rich>=13.0
+Provides-Extra: clipboard
+Requires-Dist: pyperclip; extra == 'clipboard'
+Provides-Extra: dev
+Requires-Dist: hatch; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# linkedown
+
+Bidirectional **Markdown ↔ LinkedIn Unicode** converter.
+
+LinkedIn does not render Markdown, but does display Unicode styled characters correctly.
+`linkedown` converts between the two formats — both as a CLI tool and as an MCP server
+for use by coding agents.
+
+The Markdown → LinkedIn conversion logic is derived from
+[md-to-linkedin](https://github.com/shenning00/md-to-linkedin) by Scott Henning (MIT).
+
+## Installation
+
+```sh
+pip install linkedown
+```
+
+## CLI usage
+
+```sh
+# Markdown → LinkedIn
+md2li post.md                  # print to stdout
+md2li post.md -o linkedin.txt  # write to file
+md2li post.md --copy           # copy to clipboard
+
+# LinkedIn → Markdown
+li2md post.txt
+li2md post.txt -o post.md
+
+# Pipe
+cat post.md | md2li
+```
+
+## MCP server
+
+```sh
+linkedown-mcp          # stdio server for Copilot/Claude/Codex/Cline
+uvx linkedown linkedown-mcp
+```
+
+Tools exposed:
+- `md_to_linkedin_tool` — Markdown → LinkedIn Unicode
+- `linkedin_to_md_tool` — LinkedIn Unicode → Markdown
+
+## Supported formatting
+
+| Markdown       | LinkedIn output        |
+|----------------|------------------------|
+| `**bold**`     | 𝗯𝗼𝗹𝗱 (sans-serif bold)  |
+| `*italic*`     | 𝘪𝘵𝘢𝘭𝘪𝘤               |
+| `` `code` ``   | 𝚌𝚘𝚍𝚎 (monospace)       |
+| `# Heading`    | **𝗛𝗲𝗮𝗱𝗶𝗻𝗴**            |
+| `- item`       | • item                 |
+| `` ``` `` block | ▸ prefixed lines      |
+| `> quote`      | │ quote                |
+| `[text](url)`  | text (url)             |
+| `---`          | ─────────────          |
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+Attribution: Markdown → LinkedIn conversion logic derived from
+[shenning00/md-to-linkedin](https://github.com/shenning00/md-to-linkedin) (MIT).

linkedown-0.1.0/README.md

@@ -0,0 +1,64 @@
+# linkedown
+
+Bidirectional **Markdown ↔ LinkedIn Unicode** converter.
+
+LinkedIn does not render Markdown, but does display Unicode styled characters correctly.
+`linkedown` converts between the two formats — both as a CLI tool and as an MCP server
+for use by coding agents.
+
+The Markdown → LinkedIn conversion logic is derived from
+[md-to-linkedin](https://github.com/shenning00/md-to-linkedin) by Scott Henning (MIT).
+
+## Installation
+
+```sh
+pip install linkedown
+```
+
+## CLI usage
+
+```sh
+# Markdown → LinkedIn
+md2li post.md                  # print to stdout
+md2li post.md -o linkedin.txt  # write to file
+md2li post.md --copy           # copy to clipboard
+
+# LinkedIn → Markdown
+li2md post.txt
+li2md post.txt -o post.md
+
+# Pipe
+cat post.md | md2li
+```
+
+## MCP server
+
+```sh
+linkedown-mcp          # stdio server for Copilot/Claude/Codex/Cline
+uvx linkedown linkedown-mcp
+```
+
+Tools exposed:
+- `md_to_linkedin_tool` — Markdown → LinkedIn Unicode
+- `linkedin_to_md_tool` — LinkedIn Unicode → Markdown
+
+## Supported formatting
+
+| Markdown       | LinkedIn output        |
+|----------------|------------------------|
+| `**bold**`     | 𝗯𝗼𝗹𝗱 (sans-serif bold)  |
+| `*italic*`     | 𝘪𝘵𝘢𝘭𝘪𝘤               |
+| `` `code` ``   | 𝚌𝚘𝚍𝚎 (monospace)       |
+| `# Heading`    | **𝗛𝗲𝗮𝗱𝗶𝗻𝗴**            |
+| `- item`       | • item                 |
+| `` ``` `` block | ▸ prefixed lines      |
+| `> quote`      | │ quote                |
+| `[text](url)`  | text (url)             |
+| `---`          | ─────────────          |
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+Attribution: Markdown → LinkedIn conversion logic derived from
+[shenning00/md-to-linkedin](https://github.com/shenning00/md-to-linkedin) (MIT).

linkedown-0.1.0/pyproject.toml

@@ -0,0 +1,61 @@
+[project]
+name = "linkedown"
+version = "0.1.0"
+description = "Bidirectional Markdown ↔ LinkedIn Unicode converter. CLI and MCP tools."
+readme = {file = "README.md", content-type = "text/markdown"}
+authors = [{name = "Gregory R. Warnes", email = "greg@warnes-innovations.com"}]
+license = {text = "MIT"}
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+keywords = ["linkedin", "markdown", "converter", "unicode", "mcp", "cli"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Text Processing :: Markup :: Markdown",
+    "Topic :: Utilities",
+    "Typing :: Typed",
+]
+# md→li direction uses mistune + click + rich (same as upstream md-to-linkedin).
+# li→md direction is pure stdlib; no extra deps.
+# mcp dependency is for the MCP server.
+dependencies = [
+    "click>=8.0",
+    "mistune>=3.0",
+    "mcp>=1.0",
+    "rich>=13.0",
+]
+
+[project.optional-dependencies]
+clipboard = ["pyperclip"]
+dev     = ["pytest>=8.0", "pytest-cov", "ruff", "mypy", "hatch"]
+
+[project.urls]
+Homepage  = "https://github.com/Warnes-Innovations/linkedown"
+Repository = "https://github.com/Warnes-Innovations/linkedown"
+Issues    = "https://github.com/Warnes-Innovations/linkedown/issues"
+
+[project.scripts]
+md2li   = "linkedown.cli:md2li_main"
+li2md   = "linkedown.cli:li2md_main"
+linkedown-mcp = "linkedown.server:main"
+
+[build-system]
+requires      = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.sdist]
+include = ["/LICENSE", "/README.md", "/src"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.mypy]
+python_version = "3.11"
+strict = true

linkedown-0.1.0/src/linkedown/__init__.py

@@ -0,0 +1,9 @@
+# Copyright (c) 2026 Gregory R. Warnes
+# SPDX-License-Identifier: MIT
+"""linkedown — Bidirectional Markdown ↔ LinkedIn Unicode converter."""
+
+from .li_to_md import linkedin_to_md
+from .md_to_li import md_to_linkedin
+
+__all__ = ["md_to_linkedin", "linkedin_to_md"]
+__version__ = "0.1.0"

linkedown-0.1.0/src/linkedown/cli.py

@@ -0,0 +1,167 @@
+"""Command-line interface for linkedown.
+
+Provides two entry points:
+    md2li   — Markdown → LinkedIn Unicode
+    li2md   — LinkedIn Unicode → Markdown
+
+Both commands share the same input/output plumbing:
+
+    <cmd> FILE          Read from file, write to stdout
+    <cmd> -             Read from stdin, write to stdout
+    <cmd> FILE -o OUT   Read from file, write to OUT
+    <cmd> FILE --copy   Read from file, copy to clipboard
+    cat f | <cmd>       Stdin → stdout (piped)
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+
+from . import __version__, linkedin_to_md, md_to_linkedin
+
+try:
+    import pyperclip as _pyperclip
+except ImportError:
+    _pyperclip = None  # type: ignore[assignment]
+
+console = Console()
+
+# ---------------------------------------------------------------------------
+# Shared I/O helpers
+# ---------------------------------------------------------------------------
+
+
+def _read(input_file: Optional[Path]) -> str:
+    if input_file is None or str(input_file) == "-":
+        if input_file is None and sys.stdin.isatty():
+            raise click.UsageError(
+                "No input file specified and stdin is not being piped. "
+                "Pass a filename or pipe input via stdin."
+            )
+        return sys.stdin.read()
+    if not input_file.exists():
+        raise click.FileError(str(input_file), hint="File not found")
+    if not input_file.is_file():
+        raise click.FileError(str(input_file), hint="Path is not a file")
+    return input_file.read_text(encoding="utf-8")
+
+
+def _write(text: str, output_file: Optional[Path], copy: bool, quiet: bool) -> None:
+    if copy:
+        if _pyperclip is None:
+            raise click.ClickException(
+                "Clipboard support requires the 'pyperclip' package: "
+                "pip install 'linkedown[clipboard]'"
+            )
+        _pyperclip.copy(text)
+        if not quiet:
+            console.print("[green]✓[/green] Copied to clipboard.")
+        return
+
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        output_file.write_text(text, encoding="utf-8")
+        if not quiet:
+            console.print(f"[green]✓[/green] Written to {output_file}")
+        return
+
+    sys.stdout.write(text)
+    if not text.endswith("\n"):
+        sys.stdout.write("\n")
+
+
+# ---------------------------------------------------------------------------
+# Shared Click options
+# ---------------------------------------------------------------------------
+
+_INPUT_ARG = click.argument(
+    "input_file",
+    type=click.Path(exists=False, path_type=Path),
+    required=False,
+)
+_OUTPUT_OPT = click.option(
+    "-o", "--output", "output_file",
+    type=click.Path(path_type=Path),
+    help="Write output to FILE instead of stdout.",
+)
+_COPY_OPT = click.option(
+    "-c", "--copy", "copy_to_clipboard",
+    is_flag=True,
+    help="Copy output to clipboard (requires pyperclip).",
+)
+_QUIET_OPT = click.option(
+    "-q", "--quiet",
+    is_flag=True,
+    help="Suppress informational messages.",
+)
+
+
+# ---------------------------------------------------------------------------
+# md2li command
+# ---------------------------------------------------------------------------
+
+
+@click.command("md2li")
+@_INPUT_ARG
+@_OUTPUT_OPT
+@_COPY_OPT
+@_QUIET_OPT
+@click.version_option(version=__version__, prog_name="md2li")
+def md2li_main(
+    input_file: Optional[Path],
+    output_file: Optional[Path],
+    copy_to_clipboard: bool,
+    quiet: bool,
+) -> None:
+    """Convert Markdown to LinkedIn Unicode-formatted text.
+
+    \b
+    Examples:
+        md2li post.md
+        md2li post.md -o linkedin.txt
+        md2li post.md --copy
+        cat post.md | md2li
+    """
+    text = _read(input_file)
+    result = md_to_linkedin(text)
+    _write(result, output_file, copy_to_clipboard, quiet)
+
+
+# ---------------------------------------------------------------------------
+# li2md command
+# ---------------------------------------------------------------------------
+
+
+@click.command("li2md")
+@_INPUT_ARG
+@_OUTPUT_OPT
+@_COPY_OPT
+@_QUIET_OPT
+@click.version_option(version=__version__, prog_name="li2md")
+def li2md_main(
+    input_file: Optional[Path],
+    output_file: Optional[Path],
+    copy_to_clipboard: bool,
+    quiet: bool,
+) -> None:
+    """Convert LinkedIn Unicode-formatted text to Markdown.
+
+    The conversion is heuristic: structure (headings, lists, code blocks)
+    is inferred from LinkedIn rendering conventions. Results are generally
+    clean for posts created with md2li or similar tools.
+
+    \b
+    Examples:
+        li2md post.txt
+        li2md post.txt -o post.md
+        li2md post.txt --copy
+        cat post.txt | li2md
+    """
+    text = _read(input_file)
+    result = linkedin_to_md(text)
+    _write(result, output_file, copy_to_clipboard, quiet)

linkedown-0.1.0/src/linkedown/li_to_md.py

@@ -0,0 +1,249 @@
+"""LinkedIn Unicode → Markdown converter.
+
+This is an original addition to the linkedown package, contributed back to
+the md-to-linkedin upstream project via PR. The reverse direction is
+inherently heuristic: LinkedIn posts have no explicit structural metadata,
+so headings, bold spans, and italic spans are inferred from context.
+
+Heuristic rules applied (in order):
+1. Lines whose *entire visible content* is bold Unicode → ``# Heading``
+   (level 1 only; LinkedIn has no heading hierarchy).
+2. Bullet lines (``• …``) → ``- …``
+3. Blockquote lines (``│ …``) → ``> …``
+4. Code-block lines (``▸ …``) → fenced ``` block
+5. Thematic break line (``─…``) → ``---``
+6. Inline bold spans  → ``**…**``
+7. Inline italic spans → ``*…*``
+8. Inline monospace spans → `` `…` ``
+9. Link references ``text (url)`` → ``[text](url)``  (URL heuristic)
+10. Image references ``[Image: alt] url`` → ``![alt](url)``
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Final
+
+from .unicode_maps import _ALL_STYLED_TO_ASCII, char_style, strip_styling
+
+# ---------------------------------------------------------------------------
+# Structural patterns
+# ---------------------------------------------------------------------------
+
+_BULLET_RE:     Final[re.Pattern[str]] = re.compile(r"^[•]\s+(.*)")
+_QUOTE_RE:      Final[re.Pattern[str]] = re.compile(r"^│\s?(.*)")
+_CODE_LINE_RE:  Final[re.Pattern[str]] = re.compile(r"^▸\s?(.*)")
+_HRULE_RE:      Final[re.Pattern[str]] = re.compile(r"^─{3,}\s*$")
+_IMAGE_REF_RE:  Final[re.Pattern[str]] = re.compile(r"^\[Image:\s*(.*?)\]\s+(\S+)\s*$")
+# Link: "some text (https://example.com)" — only treat URLs in parens as links
+_LINK_INLINE_RE: Final[re.Pattern[str]] = re.compile(
+    r"(.*?)\s+\((https?://[^\s)]+)\)"
+)
+
+# ---------------------------------------------------------------------------
+# Inline span reconstruction
+# ---------------------------------------------------------------------------
+
+
+def _spans_from_line(line: str) -> str:
+    """Convert a line of possibly-styled Unicode text to Markdown inline syntax.
+
+    Segments of consecutive characters sharing the same style are wrapped in
+    the appropriate Markdown delimiter. Plain characters are emitted as-is.
+
+    Style → delimiter mapping:
+    - bold        → **…**
+    - italic      → *…*
+    - monospace   → `…`
+    - bold_italic → ***…***   (best approximation)
+    """
+    if not line:
+        return line
+
+    # Build list of (char, style_or_None)
+    segments: list[tuple[str, str | None]] = [
+        (_ALL_STYLED_TO_ASCII.get(c, (c, None))[0], char_style(c)) for c in line
+    ]
+
+    # Maximum number of plain (neutral) characters allowed as a bridge between
+    # two same-style spans.  Keeps " " and ", " inside a span while leaving
+    # longer plain phrases (e.g. plain brand names like "oboe-mcp") outside.
+    _MAX_BRIDGE = 4
+
+    result: list[str] = []
+    i = 0
+    while i < len(segments):
+        ascii_ch, style = segments[i]
+        if style is None:
+            result.append(ascii_ch)
+            i += 1
+        else:
+            # Collect run of the same style, bridging short neutral gaps.
+            j = i
+            run_chars: list[str] = []
+            while j < len(segments):
+                ch, st = segments[j]
+                if st == style:
+                    run_chars.append(ch)
+                    j += 1
+                elif st is None:
+                    # Peek ahead: collect the neutral gap, then check what follows.
+                    gap: list[str] = []
+                    k = j
+                    while k < len(segments) and segments[k][1] is None:
+                        gap.append(segments[k][0])
+                        k += 1
+                    # Bridge only if the gap is short and more same-style follows.
+                    if (
+                        k < len(segments)
+                        and segments[k][1] == style
+                        and len(gap) <= _MAX_BRIDGE
+                    ):
+                        run_chars.extend(gap)
+                        j = k
+                    else:
+                        break
+                else:
+                    break  # Different style — end run.
+            run_text = "".join(run_chars)
+            delim = {
+                "bold":        "**",
+                "italic":      "*",
+                "monospace":   "`",
+                "bold_italic": "***",
+            }.get(style, "")
+            result.append(f"{delim}{run_text}{delim}")
+            i = j
+
+    return "".join(result)
+
+
+# ---------------------------------------------------------------------------
+# Line-level checks
+# ---------------------------------------------------------------------------
+
+
+def _is_all_bold(line: str) -> bool:
+    """Return True if every alphanumeric character in *line* is bold Unicode."""
+    has_alpha = False
+    for c in line:
+        if c.isspace() or not c.isascii() and c not in _ALL_STYLED_TO_ASCII:
+            # structural punctuation — ignore
+            continue
+        style = char_style(c)
+        if style is None and (c.isalpha() or c.isdigit()):
+            return False  # plain alphanumeric → not a heading
+        if style == "bold":
+            has_alpha = True
+        elif style is not None:
+            return False  # mixed style → not a heading
+    return has_alpha
+
+
+# ---------------------------------------------------------------------------
+# Block-level reconstruction helpers
+# ---------------------------------------------------------------------------
+
+
+def _flush_code(code_lines: list[str]) -> str:
+    """Wrap accumulated code lines in a fenced block."""
+    return "```\n" + "\n".join(code_lines) + "\n```\n"
+
+
+def _apply_link_heuristic(text: str) -> str:
+    """Convert 'label (url)' → '[label](url)' for HTTP/HTTPS URLs."""
+    return _LINK_INLINE_RE.sub(r"[\1](\2)", text)
+
+
+def _apply_image_heuristic(text: str) -> str:
+    """Convert '[Image: alt] url' → '![alt](url)'."""
+    return _IMAGE_REF_RE.sub(r"![\1](\2)", text)
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def linkedin_to_md(text: str) -> str:
+    """Convert LinkedIn Unicode-formatted text to Markdown.
+
+    This conversion is heuristic. Structure (headings, lists, code blocks,
+    blockquotes) is inferred from LinkedIn rendering conventions used by
+    md-to-linkedin and similar tools. Inline bold/italic/monospace spans are
+    reconstructed from Unicode block membership.
+
+    Args:
+        text: LinkedIn post text, potentially containing Unicode styled characters.
+
+    Returns:
+        Approximate Markdown equivalent of the input.
+    """
+    lines = text.splitlines()
+    output: list[str] = []
+    code_buffer: list[str] = []
+    in_code_block = False
+
+    for raw_line in lines:
+        # --- Code block lines (▸) ---
+        code_match = _CODE_LINE_RE.match(raw_line)
+        if code_match:
+            in_code_block = True
+            code_buffer.append(code_match.group(1))
+            continue
+
+        # Flush code block when we leave code territory
+        if in_code_block:
+            output.append(_flush_code(code_buffer))
+            code_buffer = []
+            in_code_block = False
+
+        # --- Thematic break ---
+        if _HRULE_RE.match(raw_line):
+            output.append("---\n")
+            continue
+
+        # --- Image reference ---
+        if _IMAGE_REF_RE.match(raw_line):
+            output.append(_apply_image_heuristic(raw_line) + "\n")
+            continue
+
+        # --- Blockquote ---
+        quote_match = _QUOTE_RE.match(raw_line)
+        if quote_match:
+            inner = _spans_from_line(quote_match.group(1))
+            output.append(f"> {inner}\n")
+            continue
+
+        # --- Bullet list ---
+        bullet_match = _BULLET_RE.match(raw_line)
+        if bullet_match:
+            inner = _spans_from_line(bullet_match.group(1))
+            inner = _apply_link_heuristic(inner)
+            output.append(f"- {inner}\n")
+            continue
+
+        # --- Empty line ---
+        if not raw_line.strip():
+            output.append("\n")
+            continue
+
+        # --- Heading heuristic: entirely bold non-empty line ---
+        if _is_all_bold(raw_line):
+            plain = strip_styling(raw_line)
+            output.append(f"# {plain}\n")
+            continue
+
+        # --- Regular paragraph line ---
+        converted = _spans_from_line(raw_line)
+        converted = _apply_link_heuristic(converted)
+        converted = _apply_image_heuristic(converted)
+        output.append(converted + "\n")
+
+    # Flush any trailing code block
+    if in_code_block and code_buffer:
+        output.append(_flush_code(code_buffer))
+
+    # Collapse runs of more than two blank lines
+    result = re.sub(r"\n{3,}", "\n\n", "".join(output))
+    return result.lstrip("\n")

linkedown-0.1.0/src/linkedown/md_to_li.py

@@ -0,0 +1,166 @@
+"""Markdown → LinkedIn Unicode converter.
+
+Core conversion logic is derived from md-to-linkedin by Scott Henning
+(https://github.com/shenning00/md-to-linkedin), MIT licence, with minor
+adaptations for integration into linkedown.
+
+Changes vs. upstream:
+- Renderer and converter inlined here; no separate renderer.py
+- ``convert()`` accepts the same ``options`` dict as upstream for compatibility
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Final, Optional
+
+import mistune
+from mistune.core import BlockState
+
+from .unicode_maps import to_bold, to_italic, to_monospace
+
+MAX_CONSECUTIVE_BLANK_LINES: Final[int] = 2
+
+
+# ---------------------------------------------------------------------------
+# Renderer
+# ---------------------------------------------------------------------------
+
+
+class _LinkedInRenderer(mistune.BaseRenderer):
+    """mistune renderer that converts Markdown tokens to LinkedIn Unicode text."""
+
+    NAME = "linkedin"
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def render_token(self, token: dict[str, Any], state: BlockState) -> str:
+        func = self._get_method(token["type"])
+        attrs = token.get("attrs")
+        if "raw" in token:
+            text = token["raw"]
+        elif "children" in token:
+            text = self.render_tokens(token["children"], state)
+        else:
+            return func(**attrs) if attrs else func()
+        return func(text, **attrs) if attrs else func(text)
+
+    def blank_line(self) -> str:
+        return ""
+
+    def block_text(self, text: str) -> str:
+        return text
+
+    def text(self, text: str) -> str:
+        return text
+
+    def heading(self, text: str, level: int, **_: Any) -> str:
+        return f"{to_bold(text)}\n\n"
+
+    def paragraph(self, text: str) -> str:
+        return f"{text}\n\n"
+
+    def emphasis(self, text: str) -> str:
+        return to_italic(text)
+
+    def strong(self, text: str) -> str:
+        return to_bold(text)
+
+    def codespan(self, text: str) -> str:
+        return to_monospace(text)
+
+    def block_code(self, code: str, info: Optional[str] = None) -> str:
+        code = code.rstrip("\n")
+        lines = [f"▸ {line}" for line in code.split("\n")]
+        return "\n".join(lines) + "\n\n"
+
+    def list(self, body: str, ordered: bool, **_: Any) -> str:
+        return body + "\n"
+
+    def list_item(self, text: str, **_: Any) -> str:
+        return f"• {text.rstrip()}\n"
+
+    def link(self, text: str, url: str, title: Optional[str] = None) -> str:
+        return f"{text} ({url})"
+
+    def image(self, alt: str, url: str, title: Optional[str] = None) -> str:
+        return f"[Image: {alt}] {url}"
+
+    def block_quote(self, text: str) -> str:
+        text = text.rstrip("\n")
+        lines = [f"│ {line}" for line in text.split("\n")]
+        return "\n".join(lines) + "\n\n"
+
+    def thematic_break(self) -> str:
+        return "─────────────\n\n"
+
+    def newline(self) -> str:
+        return "\n"
+
+    def linebreak(self) -> str:
+        return "\n"
+
+    def softbreak(self) -> str:
+        return " "
+
+    def inline_html(self, html: str) -> str:
+        return html
+
+    def raw_html(self, html: str) -> str:
+        return html
+
+    def strikethrough(self, text: str) -> str:
+        return text
+
+    def table(self, text: str) -> str:
+        return text + "\n"
+
+    def table_head(self, text: str) -> str:
+        return text
+
+    def table_body(self, text: str) -> str:
+        return text
+
+    def table_row(self, text: str) -> str:
+        return text + "\n"
+
+    def table_cell(self, text: str, **_: Any) -> str:
+        return f"| {text} "
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def md_to_linkedin(markdown_text: str, options: Optional[dict[str, Any]] = None) -> str:
+    """Convert Markdown text to LinkedIn-compatible Unicode-formatted text.
+
+    Args:
+        markdown_text: Standard Markdown input.
+        options: Reserved for future configuration (ignored currently).
+
+    Returns:
+        LinkedIn-compatible plain-text with Unicode bold/italic/monospace.
+    """
+    renderer = _LinkedInRenderer()
+    plugins = []
+    try:
+        plugins = ["strikethrough", "table"]
+    except Exception:
+        pass
+
+    markdown = mistune.create_markdown(renderer=renderer, plugins=plugins)
+    rendered = markdown(markdown_text)
+    if not isinstance(rendered, str):
+        raise TypeError(f"Expected str from renderer, got {type(rendered)}")
+    return _post_process(rendered)
+
+
+def _post_process(text: str) -> str:
+    text = text.replace("\r\n", "\n").replace("\r", "\n")
+    lines = text.split("\n")
+    text = "\n".join(line.rstrip() for line in lines)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.rstrip("\n") + "\n"

linkedown-0.1.0/src/linkedown/server.py

@@ -0,0 +1,70 @@
+# Copyright (c) 2026 Gregory R. Warnes
+# SPDX-License-Identifier: MIT
+"""linkedown MCP server.
+
+Exposes two tools for use by coding agents:
+    md_to_linkedin  — Convert Markdown text to LinkedIn Unicode-formatted text
+    linkedin_to_md  — Convert LinkedIn Unicode text back to Markdown
+
+Run as a standalone server:
+    linkedown-mcp
+    uvx linkedown linkedown-mcp
+"""
+
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP
+
+from . import linkedin_to_md, md_to_linkedin
+
+mcp = FastMCP(
+    "linkedown",
+    instructions=(
+        "Tools for converting between Markdown and LinkedIn Unicode formatting. "
+        "Use md_to_linkedin when preparing a post for LinkedIn. "
+        "Use linkedin_to_md to convert existing LinkedIn text back to Markdown."
+    ),
+)
+
+
+@mcp.tool()
+def md_to_linkedin_tool(markdown_text: str) -> str:
+    """Convert Markdown text to LinkedIn-compatible Unicode-formatted text.
+
+    LinkedIn does not render Markdown, but does display Unicode styled characters
+    correctly. This tool converts **bold**, *italic*, `code`, headings, lists,
+    blockquotes, and code blocks to their LinkedIn-compatible equivalents.
+
+    Args:
+        markdown_text: Standard Markdown-formatted text.
+
+    Returns:
+        LinkedIn-compatible plain text with Unicode bold/italic/monospace styling.
+    """
+    return md_to_linkedin(markdown_text)
+
+
+@mcp.tool()
+def linkedin_to_md_tool(linkedin_text: str) -> str:
+    """Convert LinkedIn Unicode-formatted text back to Markdown.
+
+    Reconstructs Markdown structure (headings, lists, code blocks, blockquotes)
+    and inline formatting (bold, italic, monospace) from LinkedIn Unicode characters.
+    The conversion is heuristic: results are best for posts originally created
+    from Markdown.
+
+    Args:
+        linkedin_text: Text copied from a LinkedIn post, containing Unicode styling.
+
+    Returns:
+        Approximate Markdown equivalent of the input.
+    """
+    return linkedin_to_md(linkedin_text)
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

linkedown-0.1.0/src/linkedown/unicode_maps.py

@@ -0,0 +1,185 @@
+"""Unicode character mapping tables for LinkedIn ↔ Markdown text style transformations.
+
+The forward (Markdown → LinkedIn) character maps and conversion functions in this
+module are derived from md-to-linkedin by Scott Henning
+(https://github.com/shenning00/md-to-linkedin), licensed MIT.
+
+The inverse (LinkedIn → Markdown) maps and ``from_*`` functions are original additions
+contributed back to that project via upstream PR.
+
+Unicode ranges used:
+- Bold:        U+1D5D4–U+1D607 (A–Z, a–z),  U+1D7EC–U+1D7F5 (0–9)  [Sans-Serif Bold]
+- Italic:      U+1D434–U+1D467 (A–Z, a–z)
+- Bold-Italic: U+1D468–U+1D49B (A–Z, a–z)
+- Monospace:   U+1D670–U+1D6A3 (A–Z, a–z),  U+1D7F6–U+1D7FF (0–9)
+
+Unsupported characters (punctuation, whitespace, etc.) pass through unchanged in
+both directions.
+"""
+
+from __future__ import annotations
+
+from typing import Final
+
+# ---------------------------------------------------------------------------
+# Forward maps: ASCII → Unicode styled
+# ---------------------------------------------------------------------------
+
+# Bold (Mathematical Sans-Serif Bold)
+# A-Z → U+1D5D4-U+1D5ED
+BOLD_UPPER: Final[dict[str, str]] = {
+    chr(ord("A") + i): chr(0x1D5D4 + i) for i in range(26)
+}
+# a-z → U+1D5EE-U+1D607
+BOLD_LOWER: Final[dict[str, str]] = {
+    chr(ord("a") + i): chr(0x1D5EE + i) for i in range(26)
+}
+# 0-9 → U+1D7EC-U+1D7F5
+BOLD_DIGITS: Final[dict[str, str]] = {
+    chr(ord("0") + i): chr(0x1D7EC + i) for i in range(10)
+}
+
+# Italic (Mathematical Italic)
+# A-Z → U+1D434-U+1D44D
+# Note: H (capital) is contiguous; h (lowercase) has a gap at U+210E
+ITALIC_UPPER: Final[dict[str, str]] = {
+    chr(ord("A") + i): chr(0x1D434 + i) for i in range(26)
+}
+# a-z → U+1D44E-U+1D467  (italic 'h' is special: U+210E)
+ITALIC_LOWER: Final[dict[str, str]] = {
+    chr(ord("a") + i): chr(0x1D44E + i) if i != 7 else chr(0x210E) for i in range(26)
+}
+
+# Sans-Serif Italic (used by some external LinkedIn formatting tools)
+# A-Z → U+1D608-U+1D621
+_SANS_SERIF_ITALIC_UPPER: Final[dict[str, str]] = {
+    chr(ord("A") + i): chr(0x1D608 + i) for i in range(26)
+}
+# a-z → U+1D622-U+1D63B
+_SANS_SERIF_ITALIC_LOWER: Final[dict[str, str]] = {
+    chr(ord("a") + i): chr(0x1D622 + i) for i in range(26)
+}
+
+# Bold-Italic (Mathematical Bold Italic)
+# A-Z → U+1D468-U+1D481
+BOLD_ITALIC_UPPER: Final[dict[str, str]] = {
+    chr(ord("A") + i): chr(0x1D468 + i) for i in range(26)
+}
+# a-z → U+1D482-U+1D49B
+BOLD_ITALIC_LOWER: Final[dict[str, str]] = {
+    chr(ord("a") + i): chr(0x1D482 + i) for i in range(26)
+}
+
+# Monospace (Mathematical Monospace)
+# A-Z → U+1D670-U+1D689
+MONOSPACE_UPPER: Final[dict[str, str]] = {
+    chr(ord("A") + i): chr(0x1D670 + i) for i in range(26)
+}
+# a-z → U+1D68A-U+1D6A3
+MONOSPACE_LOWER: Final[dict[str, str]] = {
+    chr(ord("a") + i): chr(0x1D68A + i) for i in range(26)
+}
+# 0-9 → U+1D7F6-U+1D7FF
+MONOSPACE_DIGITS: Final[dict[str, str]] = {
+    chr(ord("0") + i): chr(0x1D7F6 + i) for i in range(10)
+}
+
+# ---------------------------------------------------------------------------
+# Inverse maps: Unicode styled → ASCII  (derived automatically)
+# ---------------------------------------------------------------------------
+
+_BOLD_TO_ASCII: Final[dict[str, str]] = {
+    **{v: k for k, v in BOLD_UPPER.items()},
+    **{v: k for k, v in BOLD_LOWER.items()},
+    **{v: k for k, v in BOLD_DIGITS.items()},
+}
+_ITALIC_TO_ASCII: Final[dict[str, str]] = {
+    **{v: k for k, v in ITALIC_UPPER.items()},
+    **{v: k for k, v in ITALIC_LOWER.items()},
+    # sans-serif italic (produced by some external tools) also maps to italic
+    **{v: k for k, v in _SANS_SERIF_ITALIC_UPPER.items()},
+    **{v: k for k, v in _SANS_SERIF_ITALIC_LOWER.items()},
+}
+_BOLD_ITALIC_TO_ASCII: Final[dict[str, str]] = {
+    **{v: k for k, v in BOLD_ITALIC_UPPER.items()},
+    **{v: k for k, v in BOLD_ITALIC_LOWER.items()},
+}
+_MONOSPACE_TO_ASCII: Final[dict[str, str]] = {
+    **{v: k for k, v in MONOSPACE_UPPER.items()},
+    **{v: k for k, v in MONOSPACE_LOWER.items()},
+    **{v: k for k, v in MONOSPACE_DIGITS.items()},
+}
+
+# Combined reverse map: any styled char → (ascii_char, style_name)
+# Each source dict is inverted independently to avoid key collisions when merging
+# ASCII→Unicode dicts (which share ASCII keys).
+_ALL_STYLED_TO_ASCII: Final[dict[str, tuple[str, str]]] = {
+    # Bold
+    **{v: (k, "bold") for k, v in BOLD_UPPER.items()},
+    **{v: (k, "bold") for k, v in BOLD_LOWER.items()},
+    **{v: (k, "bold") for k, v in BOLD_DIGITS.items()},
+    # Italic (mathematical)
+    **{v: (k, "italic") for k, v in ITALIC_UPPER.items()},
+    **{v: (k, "italic") for k, v in ITALIC_LOWER.items()},
+    # Italic (sans-serif, used by some external tools)
+    **{v: (k, "italic") for k, v in _SANS_SERIF_ITALIC_UPPER.items()},
+    **{v: (k, "italic") for k, v in _SANS_SERIF_ITALIC_LOWER.items()},
+    # Bold-Italic
+    **{v: (k, "bold_italic") for k, v in BOLD_ITALIC_UPPER.items()},
+    **{v: (k, "bold_italic") for k, v in BOLD_ITALIC_LOWER.items()},
+    # Monospace
+    **{v: (k, "monospace") for k, v in MONOSPACE_UPPER.items()},
+    **{v: (k, "monospace") for k, v in MONOSPACE_LOWER.items()},
+    **{v: (k, "monospace") for k, v in MONOSPACE_DIGITS.items()},
+}
+
+# ---------------------------------------------------------------------------
+# Forward conversion helpers
+# ---------------------------------------------------------------------------
+
+
+def to_bold(text: str) -> str:
+    """Convert ASCII text to Unicode Mathematical Sans-Serif Bold."""
+    return "".join(
+        BOLD_UPPER.get(c) or BOLD_LOWER.get(c) or BOLD_DIGITS.get(c) or c
+        for c in text
+    )
+
+
+def to_italic(text: str) -> str:
+    """Convert ASCII text to Unicode Mathematical Italic (letters only)."""
+    return "".join(ITALIC_UPPER.get(c) or ITALIC_LOWER.get(c) or c for c in text)
+
+
+def to_bold_italic(text: str) -> str:
+    """Convert ASCII text to Unicode Mathematical Bold Italic."""
+    return "".join(
+        BOLD_ITALIC_UPPER.get(c) or BOLD_ITALIC_LOWER.get(c) or c for c in text
+    )
+
+
+def to_monospace(text: str) -> str:
+    """Convert ASCII text to Unicode Mathematical Monospace."""
+    return "".join(
+        MONOSPACE_UPPER.get(c) or MONOSPACE_LOWER.get(c) or MONOSPACE_DIGITS.get(c) or c
+        for c in text
+    )
+
+
+# ---------------------------------------------------------------------------
+# Reverse conversion helpers
+# ---------------------------------------------------------------------------
+
+
+def strip_styling(text: str) -> str:
+    """Strip all LinkedIn Unicode styling, returning plain ASCII text.
+
+    Any character not in a styled Unicode block is passed through unchanged.
+    """
+    return "".join(_ALL_STYLED_TO_ASCII.get(c, (c, ""))[0] for c in text)
+
+
+def char_style(c: str) -> str | None:
+    """Return the style name for a styled Unicode character, or None if plain."""
+    entry = _ALL_STYLED_TO_ASCII.get(c)
+    return entry[1] if entry else None