mdship 0.0.0__py3-none-any.whl

mdship/__init__.py

@@ -0,0 +1,3 @@
+"""mdship — CLI and MCP tool for manipulating markdown files."""
+
+__version__ = "0.1.0"

mdship/cli.py

@@ -0,0 +1,106 @@
+import sys
+from importlib.metadata import version as _pkg_version
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+_VERSION = _pkg_version("mdship")
+
+app = typer.Typer(
+    help=f"mdship — markdown manipulation tool (version {_VERSION})",
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+err = Console(stderr=True)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        print(f"mdship {_VERSION}")
+        raise typer.Exit()
+
+
+@app.callback()
+def _main(
+    _: Annotated[
+        bool | None,
+        typer.Option("--version", "-V", callback=_version_callback, is_eager=True, help="Show version and exit."),
+    ] = None,
+) -> None:
+    pass
+
+
+@app.command()
+def fix_headings(
+    file: Annotated[Path, typer.Argument(help="Markdown file to process")],
+) -> None:
+    """Fix heading levels to ensure consistent hierarchy."""
+    if not file.exists():
+        err.print(f"[red]Error:[/red] file not found: {file}")
+        raise typer.Exit(1)
+
+    from mdship.markdown import fix_heading_levels
+
+    content = file.read_text()
+    fixed_content = fix_heading_levels(content)
+    print(fixed_content, end="")
+
+
+@app.command()
+def shift_headings(
+    file: Annotated[Path, typer.Argument(help="Markdown file to process")],
+    levels: Annotated[int, typer.Option("--levels", "-l", help="Number of levels to shift (positive=lower, negative=higher)")] = 1,
+) -> None:
+    """Shift all headings by the specified number of levels."""
+    if not file.exists():
+        err.print(f"[red]Error:[/red] file not found: {file}")
+        raise typer.Exit(1)
+
+    from mdship.markdown import shift_heading_levels
+
+    content = file.read_text()
+    shifted_content = shift_heading_levels(content, levels)
+    print(shifted_content, end="")
+
+
+@app.command()
+def add_checksum(
+    file: Annotated[Path, typer.Argument(help="Markdown file to process")],
+    algorithm: Annotated[str, typer.Option("--algorithm", "-a", help="Hash algorithm (md5, sha256, sha1)")] = "sha256",
+) -> None:
+    """Add or update checksum in front-matter."""
+    if not file.exists():
+        err.print(f"[red]Error:[/red] file not found: {file}")
+        raise typer.Exit(1)
+
+    from mdship.markdown import add_content_checksum
+
+    content = file.read_text()
+    updated_content = add_content_checksum(content, algorithm)
+    print(updated_content, end="")
+
+
+@app.command()
+def reflow(
+    file: Annotated[Path, typer.Argument(help="Markdown file to process")],
+    width: Annotated[int | None, typer.Option("--width", "-w", help="Line width (0 for one sentence per line)")] = None,
+) -> None:
+    """Reflow paragraphs to specified width or one sentence per line."""
+    if not file.exists():
+        err.print(f"[red]Error:[/red] file not found: {file}")
+        raise typer.Exit(1)
+
+    from mdship.markdown import reflow_paragraphs
+
+    content = file.read_text()
+    reflowed_content = reflow_paragraphs(content, width)
+    print(reflowed_content, end="")
+
+
+@app.command()
+def mcp() -> None:
+    """Start mdship as an MCP server on stdio."""
+    from mdship.mcp_server import main as mcp_main
+
+    mcp_main()

mdship/markdown.py

@@ -0,0 +1,179 @@
+"""Core markdown manipulation functions."""
+
+import hashlib
+import re
+from typing import Optional
+
+
+def fix_heading_levels(content: str) -> str:
+    """Fix heading levels to ensure consistent hierarchy.
+
+    Ensures headings follow proper nesting (no skipping from h1 to h3, etc).
+    """
+    lines = content.split("\n")
+    result = []
+    min_level = None
+
+    for line in lines:
+        match = re.match(r"^(#{1,6})\s+(.+)$", line)
+        if match:
+            level = len(match.group(1))
+            text = match.group(2)
+
+            if min_level is None:
+                min_level = level
+            else:
+                # TODO: Implement logic to adjust heading levels
+                pass
+
+            result.append(line)
+        else:
+            result.append(line)
+
+    return "\n".join(result)
+
+
+def shift_heading_levels(content: str, levels: int) -> str:
+    """Shift all headings by the specified number of levels.
+
+    Positive numbers lower the headings (h1 -> h2), negative numbers raise them (h2 -> h1).
+    """
+    lines = content.split("\n")
+    result = []
+
+    for line in lines:
+        match = re.match(r"^(#{1,6})\s+(.+)$", line)
+        if match:
+            current_level = len(match.group(1))
+            text = match.group(2)
+            new_level = max(1, min(6, current_level + levels))
+            result.append("#" * new_level + " " + text)
+        else:
+            result.append(line)
+
+    return "\n".join(result)
+
+
+def add_content_checksum(content: str, algorithm: str = "sha256") -> str:
+    """Add or update checksum in front-matter.
+
+    Supports md5, sha1, and sha256 algorithms.
+    """
+    lines = content.split("\n")
+
+    if not lines or lines[0] != "---":
+        # No YAML front-matter, prepend it
+        hash_obj = hashlib.new(algorithm)
+        hash_obj.update(content.encode())
+        checksum = hash_obj.hexdigest()
+        front_matter = f"---\nchecksum: {checksum}\nchecksum_algorithm: {algorithm}\n---\n"
+        return front_matter + content
+
+    # Find the closing --- of front-matter
+    end_idx = None
+    for i in range(1, len(lines)):
+        if lines[i] == "---":
+            end_idx = i
+            break
+
+    if end_idx is None:
+        # Malformed front-matter, just add at the beginning
+        hash_obj = hashlib.new(algorithm)
+        hash_obj.update(content.encode())
+        checksum = hash_obj.hexdigest()
+        front_matter = f"---\nchecksum: {checksum}\nchecksum_algorithm: {algorithm}\n---\n"
+        return front_matter + content
+
+    # Calculate checksum of the content (excluding front-matter)
+    content_without_fm = "\n".join(lines[end_idx + 1 :])
+    hash_obj = hashlib.new(algorithm)
+    hash_obj.update(content_without_fm.encode())
+    checksum = hash_obj.hexdigest()
+
+    # Update or add checksum fields in front-matter
+    fm_lines = lines[1:end_idx]
+    checksum_line = f"checksum: {checksum}"
+    algorithm_line = f"checksum_algorithm: {algorithm}"
+
+    # Remove existing checksum lines
+    fm_lines = [
+        line
+        for line in fm_lines
+        if not line.startswith("checksum:") and not line.startswith("checksum_algorithm:")
+    ]
+
+    # Add new checksum lines
+    fm_lines.append(checksum_line)
+    fm_lines.append(algorithm_line)
+
+    result = ["---"] + fm_lines + ["---"] + lines[end_idx + 1 :]
+    return "\n".join(result)
+
+
+def reflow_paragraphs(content: str, width: Optional[int] = None) -> str:
+    """Reflow paragraphs to specified width or one sentence per line.
+
+    If width is None or 0, splits into one sentence per line.
+    Otherwise, reflows to the specified width.
+    """
+    lines = content.split("\n")
+    result = []
+    in_code_block = False
+    current_paragraph = []
+
+    for line in lines:
+        # Track code blocks
+        if line.startswith("```"):
+            in_code_block = not in_code_block
+
+        if in_code_block:
+            if current_paragraph:
+                result.extend(_reflow_paragraph(current_paragraph, width))
+                current_paragraph = []
+            result.append(line)
+        elif line.strip() == "":
+            # Empty line marks end of paragraph
+            if current_paragraph:
+                result.extend(_reflow_paragraph(current_paragraph, width))
+                current_paragraph = []
+            result.append("")
+        elif re.match(r"^[#\-\*]", line) or line.startswith(">"):
+            # Heading, list, or blockquote
+            if current_paragraph:
+                result.extend(_reflow_paragraph(current_paragraph, width))
+                current_paragraph = []
+            result.append(line)
+        else:
+            # Regular paragraph line
+            current_paragraph.append(line)
+
+    # Handle remaining paragraph
+    if current_paragraph:
+        result.extend(_reflow_paragraph(current_paragraph, width))
+
+    return "\n".join(result)
+
+
+def _reflow_paragraph(lines: list[str], width: Optional[int] = None) -> list[str]:
+    """Reflow a paragraph (list of lines) to the specified width or sentence per line."""
+    text = " ".join(line.strip() for line in lines if line.strip())
+
+    if width is None or width == 0:
+        # One sentence per line
+        sentences = re.split(r"(?<=[.!?])\s+", text)
+        return [s.strip() for s in sentences if s.strip()]
+    else:
+        # Reflow to width
+        result = []
+        current_line = ""
+        for word in text.split():
+            if not current_line:
+                current_line = word
+            elif len(current_line) + 1 + len(word) <= width:
+                current_line += " " + word
+            else:
+                result.append(current_line)
+                current_line = word
+        if current_line:
+            result.append(current_line)
+        return result

mdship/mcp_server.py

@@ -0,0 +1,133 @@
+"""
+MCP server for mdship.
+
+Exposes markdown manipulation tools over stdio. Start with:
+    mdship mcp
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+
+from mcp.server import Server
+from mcp.types import TextContent, Tool
+
+
+def main() -> None:
+    """Run the MCP server on stdio."""
+    server = Server("mdship")
+
+    @server.list_tools()
+    async def list_tools() -> list[Tool]:
+        return [
+            Tool(
+                name="fix_headings",
+                description="Fix heading levels to ensure consistent hierarchy",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "content": {
+                            "type": "string",
+                            "description": "Markdown content to process",
+                        }
+                    },
+                    "required": ["content"],
+                },
+            ),
+            Tool(
+                name="shift_headings",
+                description="Shift all headings by the specified number of levels",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "content": {
+                            "type": "string",
+                            "description": "Markdown content to process",
+                        },
+                        "levels": {
+                            "type": "integer",
+                            "description": "Number of levels to shift (positive=lower, negative=higher)",
+                            "default": 1,
+                        },
+                    },
+                    "required": ["content"],
+                },
+            ),
+            Tool(
+                name="add_checksum",
+                description="Add or update checksum in front-matter",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "content": {
+                            "type": "string",
+                            "description": "Markdown content to process",
+                        },
+                        "algorithm": {
+                            "type": "string",
+                            "description": "Hash algorithm (md5, sha256, sha1)",
+                            "default": "sha256",
+                        },
+                    },
+                    "required": ["content"],
+                },
+            ),
+            Tool(
+                name="reflow",
+                description="Reflow paragraphs to specified width or one sentence per line",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "content": {
+                            "type": "string",
+                            "description": "Markdown content to process",
+                        },
+                        "width": {
+                            "type": "integer",
+                            "description": "Line width (0 or null for one sentence per line)",
+                        },
+                    },
+                    "required": ["content"],
+                },
+            ),
+        ]
+
+    @server.call_tool()
+    async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+        from mdship.markdown import (
+            add_content_checksum,
+            fix_heading_levels,
+            reflow_paragraphs,
+            shift_heading_levels,
+        )
+
+        try:
+            if name == "fix_headings":
+                content = arguments["content"]
+                result = fix_heading_levels(content)
+            elif name == "shift_headings":
+                content = arguments["content"]
+                levels = arguments.get("levels", 1)
+                result = shift_heading_levels(content, levels)
+            elif name == "add_checksum":
+                content = arguments["content"]
+                algorithm = arguments.get("algorithm", "sha256")
+                result = add_content_checksum(content, algorithm)
+            elif name == "reflow":
+                content = arguments["content"]
+                width = arguments.get("width")
+                result = reflow_paragraphs(content, width)
+            else:
+                return [TextContent(type="text", text=f"Unknown tool: {name}")]
+
+            return [TextContent(type="text", text=result)]
+        except Exception as e:
+            return [TextContent(type="text", text=f"Error: {str(e)}")]
+
+    async def run():
+        async with server:
+            await server.wait_for_shutdown()
+
+    asyncio.run(run())

mdship-0.0.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: mdship
+Version: 0.0.0
+Summary: CLI and MCP tool for manipulating markdown files
+Requires-Python: >=3.11
+Requires-Dist: mcp>=1.0
+Requires-Dist: rich>=13
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'

mdship-0.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+mdship/__init__.py,sha256=kWJ5Ylr_DHKHbd2myITrih0VfZdWVAKqfgj5C0nf66A,90
+mdship/cli.py,sha256=QVeTombjQe_dvZk58ExEW_HBi5cmoxLVS36f_26Rh_4,3157
+mdship/markdown.py,sha256=HOw2B_NHurpB0s2NtsPKiZLSTJMd7uvZVLc-ygCN8p8,5732
+mdship/mcp_server.py,sha256=xio11hxEw3f5MqQtebNfdPXI0G3nvHCOHPmxy3Mh-Qw,4667
+mdship-0.0.0.dist-info/METADATA,sha256=R4JsKdLR417je5CJwxWwBvOOfIPpw0EcR52W02U1PJA,309
+mdship-0.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+mdship-0.0.0.dist-info/entry_points.txt,sha256=7U-iGlLgwBr3_ccktLo4MOp_9Su38pXErzoun1opP24,42
+mdship-0.0.0.dist-info/RECORD,,

mdship-0.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

mdship-0.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mdship = mdship.cli:app