crier 2.0.0__tar.gz → 2.0.2__tar.gz

{crier-2.0.0 → crier-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crier
-Version: 2.0.0
+Version: 2.0.2
 Summary: Cross-post your content to dev.to, Hashnode, Medium, and more
 Project-URL: Homepage, https://github.com/queelius/crier
 Project-URL: Repository, https://github.com/queelius/crier

{crier-2.0.0 → crier-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "crier"
-version = "2.0.0"
+version = "2.0.2"
 description = "Cross-post your content to dev.to, Hashnode, Medium, and more"
 readme = "README.md"
 license = "MIT"

{crier-2.0.0 → crier-2.0.2}/src/crier/cli.py

@@ -20,7 +20,7 @@ from .config import (
 )
 from .converters import parse_markdown_file
 from .platforms import PLATFORMS, get_platform
-from .platforms.base import Article
+from .rewrite import apply_rewrite
 from .utils import (
     is_in_content_paths as _is_in_content_paths,
     parse_date_filter as _parse_date_filter_impl,
@@ -740,17 +740,7 @@ def publish(file: str, platform_args: tuple[str, ...], profile_name: str | None,
     if rewrite_content:
         is_rewritten = True
         posted_content = rewrite_content
-        # Create a modified article with the rewritten content
-        article = Article(
-            title=article.title,
-            body=rewrite_content,  # Use rewritten content as body
-            description=article.description,
-            tags=article.tags,
-            canonical_url=article.canonical_url,
-            published=article.published,
-            cover_image=article.cover_image,
-            is_rewrite=True,
-        )
+        article = apply_rewrite(article, rewrite_content)
 
     # Require canonical_url for registry tracking
     if not article.canonical_url:
@@ -4135,17 +4125,12 @@ def schedule_run(dry_run: bool, json_output: bool):
                 console.print(f"[red]✗[/red] {post.id}: No API key for {platform_name}")
             continue
 
-        # Handle rewrite if specified
+        # Handle rewrite if specified.
+        # Use apply_rewrite so is_rewrite=True is set; short-form platforms
+        # branch on that flag and would otherwise discard the body.
+        is_rewritten = bool(post.rewrite)
         if post.rewrite:
-            article = Article(
-                title=article.title,
-                body=post.rewrite,
-                description=article.description,
-                tags=article.tags,
-                canonical_url=article.canonical_url,
-                published=article.published,
-                cover_image=article.cover_image,
-            )
+            article = apply_rewrite(article, post.rewrite)
 
         # Publish
         try:
@@ -4165,6 +4150,8 @@ def schedule_run(dry_run: bool, json_output: bool):
                         url=result.url,
                         title=article.title,
                         source_file=str(file_path),
+                        rewritten=is_rewritten,
+                        posted_content=post.rewrite if is_rewritten else None,
                     )
 
                 results.append({

{crier-2.0.0 → crier-2.0.2}/src/crier/mcp_server.py

@@ -83,13 +83,15 @@ def _validate_platform(name: str) -> str | None:
 
 
 def _resolve_file(file_path: str) -> Path | None:
-    """Resolve a file path against project root. Returns None if not found."""
+    """Resolve a file path against project root. Returns None if not found or not a file."""
+    if not file_path:
+        return None
     from .config import get_project_root
     p = Path(file_path)
-    if p.is_absolute() and p.exists():
+    if p.is_absolute() and p.is_file():
         return p
     resolved = get_project_root() / p
-    if resolved.exists():
+    if resolved.is_file():
         return resolved
     return None
 
@@ -581,36 +583,23 @@ def crier_check(
 # ============================================================================
 
 
-@mcp.tool()
-def crier_publish(
+def _prepare_publish(
     file_path: str,
     platform: str,
-    dry_run: bool = False,
-    rewrite_content: str | None = None,
-    rewrite_author: str | None = None,
-    confirmation_token: str | None = None,
-) -> dict:
-    """Publish a content file to a platform.
+    rewrite_content: str | None,
+):
+    """Validate inputs and load the article for crier_publish.
 
-    Two-step confirmation: call without token to get a preview, then
-    call again with the returned token to execute.
-
-    For short-form platforms (bluesky, mastodon), pass rewrite_content
-    with a condensed version. Crier appends the canonical URL automatically.
+    Shared by step 1 (preview + token) and step 2 (execute). Returns either
+    an error dict (caller should return it as-is) or a tuple of
+    ``(resolved_path, article, api_key, is_rewritten, posted_content)``.
 
-    Examples:
-        # Step 1: preview
-        crier_publish("content/post/my-article/index.md", "devto")
-        # Step 2: execute
-        crier_publish("content/post/my-article/index.md", "devto",
-                      confirmation_token="abc123")
-        # Dry run (no confirmation needed)
-        crier_publish("content/post/my-article/index.md", "devto", dry_run=True)
-        # With rewrite for short-form
-        crier_publish("content/post/my-article/index.md", "bluesky",
-                      rewrite_content="Interesting take on X...",
-                      rewrite_author="claude-code")
+    The rewrite, when provided, is applied here so both branches see the
+    final Article that will be posted.
     """
+    from .converters import parse_markdown_file
+    from .config import get_api_key, get_platform_mode
+
     err = _validate_platform(platform)
     if err:
         return {"error": err}
@@ -619,13 +608,6 @@ def crier_publish(
     if not resolved:
         return {"error": f"File not found: {file_path}"}
 
-    from .converters import parse_markdown_file
-    from .config import get_api_key, get_platform_mode
-    from .platforms import get_platform
-    from .platforms.base import Article
-    from .registry import record_publication, record_failure, is_published
-
-    # Parse article
     try:
         article = parse_markdown_file(str(resolved))
     except Exception as e:
@@ -634,7 +616,6 @@ def crier_publish(
     if not article.title:
         return {"error": "Article has no title"}
 
-    # Check API key
     api_key = get_api_key(platform)
     if not api_key:
         return {"error": f"No API key configured for {platform}"}
@@ -643,106 +624,158 @@ def crier_publish(
     if mode != "api":
         return {"error": f"{platform} is in {mode} mode (not API). Use CLI for manual/import."}
 
-    # Apply rewrite if provided
     is_rewritten = bool(rewrite_content)
     posted_content = rewrite_content
     if rewrite_content:
-        article = Article(
+        from .rewrite import apply_rewrite
+        article = apply_rewrite(article, rewrite_content)
+
+    return resolved, article, api_key, is_rewritten, posted_content
+
+
+def _execute_publish(
+    resolved: Path,
+    article,
+    platform: str,
+    api_key: str,
+    is_rewritten: bool,
+    posted_content: str | None,
+    rewrite_author: str | None,
+) -> dict:
+    """Run the platform publish call and record the outcome.
+
+    Records success via record_publication and any failure (exception or
+    PublishResult.success=False) via record_failure, mirroring CLI publish
+    semantics. Returns the MCP-shaped result dict.
+    """
+    from .platforms import get_platform
+    from .registry import record_failure, record_publication
+
+    canonical = article.canonical_url
+
+    try:
+        platform_obj = get_platform(platform)(api_key)
+        result = platform_obj.publish(article)
+    except Exception as e:
+        if canonical:
+            record_failure(canonical, platform, str(e), article.title, str(resolved))
+        return {"error": f"Publish failed: {e}"}
+
+    if not result.success:
+        if canonical and result.error:
+            record_failure(canonical, platform, result.error, article.title, str(resolved))
+        return {"error": f"Publish failed: {result.error}"}
+
+    if canonical:
+        record_publication(
+            canonical_url=canonical,
+            platform=platform,
+            article_id=result.article_id,
+            url=result.url,
             title=article.title,
-            body=rewrite_content,
-            description=article.description,
-            tags=article.tags,
-            canonical_url=article.canonical_url,
-            published=article.published,
-            cover_image=article.cover_image,
-            is_rewrite=True,
+            source_file=str(resolved),
+            rewritten=is_rewritten,
+            rewrite_author=rewrite_author,
+            posted_content=posted_content,
         )
 
-    # Build preview
+    return {
+        "success": True,
+        "platform": platform,
+        "title": article.title,
+        "article_id": result.article_id,
+        "url": result.url,
+    }
+
+
+@mcp.tool()
+def crier_publish(
+    file_path: str,
+    platform: str,
+    dry_run: bool = False,
+    rewrite_content: str | None = None,
+    rewrite_author: str | None = None,
+    confirmation_token: str | None = None,
+) -> dict:
+    """Publish a content file to a platform.
+
+    Two-step confirmation: call without token to get a preview, then
+    call again with the returned token to execute.
+
+    For short-form platforms (bluesky, mastodon), pass rewrite_content
+    with a condensed version. Crier appends the canonical URL automatically.
+
+    Examples:
+        # Step 1: preview
+        crier_publish("content/post/my-article/index.md", "devto")
+        # Step 2: execute
+        crier_publish("content/post/my-article/index.md", "devto",
+                      confirmation_token="abc123")
+        # Dry run (no confirmation needed)
+        crier_publish("content/post/my-article/index.md", "devto", dry_run=True)
+        # With rewrite for short-form
+        crier_publish("content/post/my-article/index.md", "bluesky",
+                      rewrite_content="Interesting take on X...",
+                      rewrite_author="claude-code")
+    """
+    # Step 2: token is the source of truth. Caller args are ignored to prevent
+    # token-substitution bypass; see the test_*_step2_token_overrides_caller_args
+    # regressions in tests/test_mcp.py.
+    if confirmation_token:
+        details = _consume_token(confirmation_token, "publish")
+        if not details:
+            return {"error": "Invalid or expired confirmation token. Request a new one."}
+
+        prepared = _prepare_publish(
+            details["file"],
+            details["platform"],
+            details.get("rewrite_content"),
+        )
+        if isinstance(prepared, dict):
+            return prepared
+        resolved, article, api_key, is_rewritten, posted_content = prepared
+
+        return _execute_publish(
+            resolved, article, details["platform"], api_key,
+            is_rewritten, posted_content, details.get("rewrite_author"),
+        )
+
+    # Step 1 / dry_run: validate, build preview, optionally mint a token.
+    prepared = _prepare_publish(file_path, platform, rewrite_content)
+    if isinstance(prepared, dict):
+        return prepared
+    resolved, article, _api_key, is_rewritten, _posted = prepared
+
+    from .registry import is_published
+    canonical = article.canonical_url
     preview = {
         "file": str(resolved),
         "title": article.title,
         "platform": platform,
-        "canonical_url": article.canonical_url,
+        "canonical_url": canonical,
         "is_rewrite": is_rewritten,
         "body_length": len(article.body) if article.body else 0,
-        "already_published": is_published(
-            article.canonical_url or "", platform
-        ) if article.canonical_url else False,
+        "already_published": is_published(canonical, platform) if canonical else False,
     }
 
     if dry_run:
         return {"dry_run": True, "preview": preview}
 
-    # Step 1: return preview + token
-    if not confirmation_token:
-        token = _create_token("publish", {
-            "file": str(resolved), "platform": platform,
-            "rewrite_content": rewrite_content, "rewrite_author": rewrite_author,
-        })
-        return {
-            "confirmation_required": True,
-            "preview": preview,
-            "confirmation_token": token,
-            "message": f"Call again with confirmation_token to publish '{article.title}' to {platform}",
-        }
-
-    # Step 2: consume token and execute
-    details = _consume_token(confirmation_token, "publish")
-    if not details:
-        return {"error": "Invalid or expired confirmation token. Request a new one."}
-
-    # Restore rewrite from token (the caller only passes it in step 1)
-    if not rewrite_content and details.get("rewrite_content"):
-        rewrite_content = details["rewrite_content"]
-        rewrite_author = details.get("rewrite_author")
-        is_rewritten = True
-        posted_content = rewrite_content
-        article = Article(
-            title=article.title,
-            body=rewrite_content,
-            description=article.description,
-            tags=article.tags,
-            canonical_url=article.canonical_url,
-            published=article.published,
-            cover_image=article.cover_image,
-            is_rewrite=True,
-        )
-
-    # Publish
-    try:
-        platform_cls = get_platform(platform)
-        platform_obj = platform_cls(api_key)
-        result = platform_obj.publish(article)
-    except Exception as e:
-        if article.canonical_url:
-            record_failure(article.canonical_url, platform, str(e), article.title, str(resolved))
-        return {"error": f"Publish failed: {e}"}
-
-    if result.success:
-        if article.canonical_url:
-            record_publication(
-                canonical_url=article.canonical_url,
-                platform=platform,
-                article_id=result.article_id,
-                url=result.url,
-                title=article.title,
-                source_file=str(resolved),
-                rewritten=is_rewritten,
-                rewrite_author=rewrite_author,
-                posted_content=posted_content,
-            )
-        return {
-            "success": True,
-            "platform": platform,
-            "title": article.title,
-            "article_id": result.article_id,
-            "url": result.url,
-        }
-    else:
-        if article.canonical_url and result.error:
-            record_failure(article.canonical_url, platform, result.error, article.title, str(resolved))
-        return {"error": f"Publish failed: {result.error}"}
+    token = _create_token("publish", {
+        "file": str(resolved),
+        "platform": platform,
+        "rewrite_content": rewrite_content,
+        "rewrite_author": rewrite_author,
+    })
+    return {
+        "confirmation_required": True,
+        "preview": preview,
+        "confirmation_token": token,
+        "message": (
+            f"Call again with confirmation_token to publish "
+            f"'{article.title}' to {platform}"
+        ),
+    }
 
 
 @mcp.tool()
@@ -766,6 +799,20 @@ def crier_delete(
         # Delete from all platforms
         crier_delete("code-without-purpose", delete_all=True)
     """
+    from .registry import get_article
+
+    # Step 2: token is the source of truth. Caller args are ignored to prevent
+    # token-substitution bypass; see test_delete_step2_token_overrides_caller_key.
+    if confirmation_token:
+        details = _consume_token(confirmation_token, "delete")
+        if not details:
+            return {"error": "Invalid or expired confirmation token."}
+        article = get_article(details["key"])
+        if not article:
+            return {"error": f"Article not found: {details['key']}"}
+        return {"deleted": _execute_deletes(article, details["platforms"])}
+
+    # Step 1: validate, resolve targets, return preview + token.
     if platform:
         err = _validate_platform(platform)
         if err:
@@ -774,77 +821,97 @@ def crier_delete(
     if not platform and not delete_all:
         return {"error": "Specify platform or delete_all=True"}
 
-    from .registry import get_article, record_deletion, get_publication_id
-    from .config import get_api_key, get_platform_mode
-    from .platforms import get_platform
-
     article = get_article(key)
     if not article:
         return {"error": f"Article not found: {key}"}
 
-    # Determine platforms to delete from
-    target_platforms = []
+    target_platforms, err_msg = _resolve_delete_targets(article, platform, delete_all)
+    if err_msg:
+        return {"error": err_msg}
+
+    token = _create_token("delete", {"key": key, "platforms": target_platforms})
+    return {
+        "confirmation_required": True,
+        "preview": {
+            "title": article["title"],
+            "slug": article["slug"],
+            "platforms_to_delete": target_platforms,
+        },
+        "confirmation_token": token,
+        "message": f"Call again with confirmation_token to delete from {target_platforms}",
+    }
+
+
+def _resolve_delete_targets(
+    article: dict,
+    platform: str | None,
+    delete_all: bool,
+) -> tuple[list[str], str | None]:
+    """Determine which platforms a delete should target.
+
+    Returns ``(target_platforms, error)``: at most one is non-empty.
+    """
+    # Filter out failure-only rows (platform_id IS NULL) and soft-deleted rows.
+    # _article_row_to_dict surfaces all publication rows; we only want real
+    # publications. See the failure-row convention in CLAUDE.md.
+    def _is_real_publication(data: dict) -> bool:
+        return "deleted_at" not in data and bool(data.get("id"))
+
     if delete_all:
-        target_platforms = [
+        targets = [
             p for p, data in article.get("platforms", {}).items()
-            if "deleted_at" not in data
+            if _is_real_publication(data)
         ]
-    elif platform:
-        if platform not in article.get("platforms", {}):
-            return {"error": f"'{article['title']}' not published to {platform}"}
-        target_platforms = [platform]
+        if not targets:
+            return [], "Nothing to delete"
+        return targets, None
 
-    if not target_platforms:
-        return {"error": "Nothing to delete"}
+    # Single platform path; caller ensured platform is set.
+    pdata = article.get("platforms", {}).get(platform)
+    if not pdata or not pdata.get("id"):
+        return [], f"'{article['title']}' not published to {platform}"
+    if "deleted_at" in pdata:
+        return [], f"'{article['title']}' on {platform} is already deleted"
+    return [platform], None
 
-    preview = {
-        "title": article["title"],
-        "slug": article["slug"],
-        "platforms_to_delete": target_platforms,
-    }
 
-    # Step 1: return preview + token
-    if not confirmation_token:
-        token = _create_token("delete", {"key": key, "platforms": target_platforms})
-        return {
-            "confirmation_required": True,
-            "preview": preview,
-            "confirmation_token": token,
-            "message": f"Call again with confirmation_token to delete from {target_platforms}",
-        }
+def _execute_deletes(article: dict, target_platforms: list[str]) -> list[dict]:
+    """Run platform delete calls for the given article, recording each outcome.
 
-    # Step 2: consume and execute
-    details = _consume_token(confirmation_token, "delete")
-    if not details:
-        return {"error": "Invalid or expired confirmation token."}
+    Always records a deletion in the registry, even when the platform call
+    fails or the platform is in non-API mode -- the user has already consented
+    via the confirmation token, so the registry should reflect that intent.
+    """
+    from .config import get_api_key, get_platform_mode
+    from .platforms import get_platform
+    from .registry import get_publication_id, record_deletion
 
-    results = []
-    for plat in details["platforms"]:
-        canonical = article.get("canonical_url") or article["slug"]
+    canonical = article.get("canonical_url") or article["slug"]
+    results: list[dict] = []
+
+    for plat in target_platforms:
         pub_id = get_publication_id(canonical, plat)
         api_key = get_api_key(plat)
-        mode = get_platform_mode(plat)
 
-        if mode != "api" or not api_key or not pub_id:
+        # Non-API mode, missing key, or missing platform_id -> only mark in registry.
+        if get_platform_mode(plat) != "api" or not api_key or not pub_id:
             record_deletion(canonical, plat)
             results.append({"platform": plat, "status": "marked_deleted"})
             continue
 
         try:
-            platform_cls = get_platform(plat)
-            platform_obj = platform_cls(api_key)
-            del_result = platform_obj.delete(pub_id)
+            del_result = get_platform(plat)(api_key).delete(pub_id)
             record_deletion(canonical, plat)
             results.append({
                 "platform": plat,
                 "status": "deleted" if del_result.success else "marked_deleted",
-                "error": del_result.error if not del_result.success else None,
+                "error": None if del_result.success else del_result.error,
             })
         except Exception as e:
             record_deletion(canonical, plat)
             results.append({"platform": plat, "status": "marked_deleted", "error": str(e)})
 
-    return {"deleted": results}
+    return results
 
 
 @mcp.tool()
@@ -864,10 +931,11 @@ def crier_archive(key: str, archived: bool = True) -> dict:
         return {"error": f"Article not found: {key}"}
 
     success = set_archived(key, archived)
-    action = "archived" if archived else "unarchived"
+    verb = "archive" if archived else "unarchive"
+    past = "archived" if archived else "unarchived"
     if success:
-        return {"success": True, "message": f"'{article['title']}' {action}"}
-    return {"error": f"Failed to {action[:-1]}e '{key}'"}
+        return {"success": True, "message": f"'{article['title']}' {past}"}
+    return {"error": f"Failed to {verb} '{key}'"}
 
 
 # ============================================================================
@@ -963,6 +1031,11 @@ def crier_stats(key: str, platform: str | None = None) -> dict:
         crier_stats("code-without-purpose")
         crier_stats("code-without-purpose", platform="devto")
     """
+    if platform:
+        err = _validate_platform(platform)
+        if err:
+            return {"error": err}
+
     from .registry import get_cached_stats, get_article
 
     article = get_article(key)
@@ -998,6 +1071,11 @@ def crier_stats_refresh(
         crier_stats_refresh("code-without-purpose")
         crier_stats_refresh("code-without-purpose", platform="devto")
     """
+    if platform:
+        err = _validate_platform(platform)
+        if err:
+            return {"error": err}
+
     from .registry import get_article, get_all_articles, save_stats
     from .config import get_api_key, is_manual_mode_key, is_import_mode_key
     from .platforms import get_platform

{crier-2.0.0 → crier-2.0.2}/src/crier/platforms/base.py

@@ -135,6 +135,16 @@ class Platform(ABC):
             )
         return None
 
+    def _append_canonical_url(self, text: str, article: Article) -> str:
+        """Append the canonical URL to text if not already present.
+
+        Used by short-form platforms when publishing a rewrite to ensure
+        the link back to the canonical source is included.
+        """
+        if article.canonical_url and article.canonical_url not in text:
+            return f"{text}\n\n{article.canonical_url}"
+        return text
+
     def retry_request(
         self,
         method: str,

{crier-2.0.0 → crier-2.0.2}/src/crier/platforms/bluesky.py

@@ -75,10 +75,7 @@ class Bluesky(Platform):
         """
         if article.is_rewrite:
             # Body provided (e.g., via --rewrite) — use it directly
-            text = article.body
-            # Append canonical URL if not already present
-            if article.canonical_url and article.canonical_url not in text:
-                text = text + "\n\n" + article.canonical_url
+            text = self._append_canonical_url(article.body, article)
         else:
             # Auto-construct from metadata
             text_parts = [article.title]

{crier-2.0.0 → crier-2.0.2}/src/crier/platforms/linkedin.py

@@ -50,10 +50,7 @@ class LinkedIn(Platform):
         Otherwise constructs from title + description + hashtags + URL.
         """
         if article.is_rewrite:
-            text = article.body
-            if article.canonical_url and article.canonical_url not in text:
-                text = text + "\n\n" + article.canonical_url
-            return text
+            return self._append_canonical_url(article.body, article)
 
         parts = [article.title]
 

{crier-2.0.0 → crier-2.0.2}/src/crier/platforms/mastodon.py

@@ -52,10 +52,7 @@ class Mastodon(Platform):
         """
         if article.is_rewrite:
             # Body provided (e.g., via --rewrite) — use it directly
-            text = article.body
-            # Append canonical URL if not already present
-            if article.canonical_url and article.canonical_url not in text:
-                text = text + "\n\n" + article.canonical_url
+            text = self._append_canonical_url(article.body, article)
         else:
             # Auto-construct from metadata
             text_parts = [article.title]
@@ -106,9 +103,7 @@ class Mastodon(Platform):
     def update(self, article_id: str, article: Article) -> PublishResult:
         """Update an existing toot (Mastodon supports editing)."""
         if article.is_rewrite:
-            text = article.body
-            if article.canonical_url and article.canonical_url not in text:
-                text = text + "\n\n" + article.canonical_url
+            text = self._append_canonical_url(article.body, article)
         else:
             text_parts = [article.title]
             if article.description:

{crier-2.0.0 → crier-2.0.2}/src/crier/platforms/threads.py

@@ -170,10 +170,7 @@ class Threads(Platform):
         Otherwise constructs from title + description + URL + hashtags.
         """
         if article.is_rewrite:
-            text = article.body
-            if article.canonical_url and article.canonical_url not in text:
-                text = text + "\n\n" + article.canonical_url
-            return text
+            return self._append_canonical_url(article.body, article)
 
         parts = [article.title]
 

{crier-2.0.0 → crier-2.0.2}/src/crier/platforms/twitter.py

@@ -37,10 +37,7 @@ class Twitter(Platform):
         Otherwise constructs from title + hashtags + URL.
         """
         if article.is_rewrite:
-            text = article.body
-            if article.canonical_url and article.canonical_url not in text:
-                text = text + "\n\n" + article.canonical_url
-            return text
+            return self._append_canonical_url(article.body, article)
 
         parts = [article.title]
 

{crier-2.0.0 → crier-2.0.2}/src/crier/rewrite.py

@@ -4,11 +4,25 @@ Handles the LLM retry loop, truncation fallback, and Article construction
 for auto-rewritten content. Used by both publish() and audit() in cli.py.
 """
 
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 
 from .platforms.base import Article
 from .utils import truncate_at_sentence
 
+__all__ = ["AutoRewriteResult", "apply_rewrite", "auto_rewrite_for_platform"]
+
+
+def apply_rewrite(article: Article, new_body: str) -> Article:
+    """Return a copy of article with body replaced and is_rewrite=True.
+
+    Single source of truth for "the article has been rewritten for a
+    platform". Used by both the auto-rewrite retry loop and the MCP
+    server's manual rewrite path. Using ``dataclasses.replace`` ensures
+    new Article fields are picked up automatically without manual
+    constructor maintenance.
+    """
+    return replace(article, body=new_body, is_rewrite=True)
+
 
 @dataclass
 class AutoRewriteResult:
@@ -106,7 +120,7 @@ def auto_rewrite_for_platform(
                 )
             return AutoRewriteResult(
                 success=True,
-                article=_rewritten_article(article, final_text),
+                article=apply_rewrite(article, final_text),
                 rewrite_text=final_text,
             )
 
@@ -120,7 +134,7 @@ def auto_rewrite_for_platform(
                 )
             return AutoRewriteResult(
                 success=True,
-                article=_rewritten_article(article, truncated),
+                article=apply_rewrite(article, truncated),
                 rewrite_text=truncated,
             )
 
@@ -139,17 +153,3 @@ def auto_rewrite_for_platform(
             success=False,
             error=f"Auto-rewrite failed: {e}",
         )
-
-
-def _rewritten_article(original: Article, new_body: str) -> Article:
-    """Create a new Article with rewritten body, preserving metadata."""
-    return Article(
-        title=original.title,
-        body=new_body,
-        description=original.description,
-        tags=original.tags,
-        canonical_url=original.canonical_url,
-        published=original.published,
-        cover_image=original.cover_image,
-        is_rewrite=True,
-    )