fabricatio 0.3.14.dev8__tar.gz → 0.3.15.dev4__tar.gz

fabricatio-0.3.15.dev4/.github/workflows/build-package.yaml

@@ -0,0 +1,130 @@
+name: Build and Release
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  determine_changes:
+    name: Determine Release Necessity & Version Details
+    runs-on: ubuntu-latest
+    outputs:
+      version_changed: ${{ steps.check_version_change.outputs.VERSION_CHANGED }}
+      current_version: ${{ steps.get_version.outputs.CURRENT_VERSION }}
+      is_prerelease: ${{ steps.check_prerelease.outputs.IS_PRERELEASE }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Get current version from pyproject.toml
+        id: get_version
+        run: |
+          CURRENT_VERSION_RAW=$(grep '^version' pyproject.toml | cut -d '"' -f 2)
+          echo "CURRENT_VERSION=v$CURRENT_VERSION_RAW" >> $GITHUB_OUTPUT
+        shell: bash
+      - name: Get latest git tag
+        uses: JinoArch/get-latest-tag@latest
+        id: tag
+      - name: Check if version has changed against latest tag
+        id: check_version_change
+        run: |
+          LATEST_TAG=${{ steps.tag.outputs.latestTag }}
+          VERSION_FROM_PYPROJECT=${{ steps.get_version.outputs.CURRENT_VERSION }}
+          echo "Latest git tag is $LATEST_TAG"
+          echo "Current version (from pyproject.toml, prefixed with 'v') is $VERSION_FROM_PYPROJECT"
+          if [ "$LATEST_TAG" != "$VERSION_FROM_PYPROJECT" ]; then
+              echo "VERSION_CHANGED=true" >> $GITHUB_OUTPUT
+            else
+              echo "VERSION_CHANGED=false" >> $GITHUB_OUTPUT
+          fi
+        shell: bash
+      - name: Check if current version is a prerelease
+        id: check_prerelease
+        run: |
+          VERSION_FROM_PYPROJECT=${{ steps.get_version.outputs.CURRENT_VERSION }}
+          if [[ "$VERSION_FROM_PYPROJECT" == *"-"* ]]; then # e.g., v1.0.0-alpha
+            echo "IS_PRERELEASE=true" >> $GITHUB_OUTPUT
+          else
+            echo "IS_PRERELEASE=false" >> $GITHUB_OUTPUT
+          fi
+        shell: bash
+
+
+  create-release:
+    if: needs.determine_changes.outputs.version_changed == 'true'
+    name: Create Release
+    needs: determine_changes
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Packing templates
+        run: |
+          tar -czf templates.tar.gz templates
+      - name: Create Release and upload assets
+        id: create_release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.determine_changes.outputs.current_version }}
+          name: ${{ needs.determine_changes.outputs.current_version }}
+          files: |
+            templates.tar.gz
+          prerelease: ${{ needs.determine_changes.outputs.is_prerelease }}
+          generate_release_notes: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.PAT }}
+
+
+
+  check-and-release:
+    name: Build, Package, and Release
+    needs:
+      - create-release
+      - determine_changes
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ windows-latest, ubuntu-latest ]
+        python-version: [ "3.12", "3.13" ]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@v6.0.1
+        with:
+          version: "latest"
+      - name: Install nightly rust
+        run: |
+          rustup default nightly
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v3
+
+      - name: Install deps
+        run: |
+          uv sync --no-install-project  --all-extras --index https://pypi.org/simple -p ${{ matrix.python-version }} 
+
+      - name: Build
+        run: |
+          make PY=${{ matrix.python-version }}
+
+      - name: Upload assets
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.determine_changes.outputs.current_version }}
+          files: |
+            dist/*.whl
+        env:
+          GITHUB_TOKEN: ${{ secrets.PAT }}
+
+      - name: Upload to PyPI
+        if: needs.determine_changes.outputs.version_changed == 'true'
+        run: |
+          make publish PY=${{ matrix.python-version }}
+        env:
+          MATURIN_USERNAME: __token__
+          MATURIN_PASSWORD: ${{ secrets.PYPI_TOKEN }}
+

{fabricatio-0.3.14.dev8 → fabricatio-0.3.15.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.3.14.dev8
+Version: 0.3.15.dev4
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -185,4 +185,5 @@ Special thanks to the contributors and maintainers of:
 - [PyO3](https://github.com/PyO3/pyo3)
 - [Maturin](https://github.com/PyO3/maturin)
 - [Handlebars.rs](https://github.com/sunng87/handlebars-rust)
+- [LiteLLM](https://github.com/BerriAI/litellm)
 

{fabricatio-0.3.14.dev8 → fabricatio-0.3.15.dev4}/README.md

@@ -145,3 +145,4 @@ Special thanks to the contributors and maintainers of:
 - [PyO3](https://github.com/PyO3/pyo3)
 - [Maturin](https://github.com/PyO3/maturin)
 - [Handlebars.rs](https://github.com/sunng87/handlebars-rust)
+- [LiteLLM](https://github.com/BerriAI/litellm)

{fabricatio-0.3.14.dev8 → fabricatio-0.3.15.dev4}/examples/write_article/write_article.py

@@ -2,7 +2,7 @@
 
 import asyncio
 from pathlib import Path
-from typing import Optional
+from typing import List, Optional
 
 import typer
 from fabricatio import Event, WorkFlow, logger
@@ -12,11 +12,10 @@ from fabricatio.actions.article import (
     GenerateArticleProposal,
     GenerateInitialOutline,
     WriteChapterSummary,
+    WriteResearchContentSummary,
 )
 from fabricatio.actions.article_rag import ArticleConsultRAG, WriteArticleContentRAG
 from fabricatio.actions.output import DumpFinalizedOutput, PersistentAll, RenderedDump
-from fabricatio.fs import safe_text_read
-from fabricatio.models.extra.article_main import Article
 from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.task import Task
 from fabricatio.models.usages import LLMUsage
@@ -95,6 +94,11 @@ Role(
             description="Generate chapter summary based on given article outline. dump the outline to the given path. in typst format.",
             steps=(WriteChapterSummary().to_task_output(),),
         ),
+        Event.quick_instantiate(ns6 := "resc-suma"): WorkFlow(
+            name="Research Content Summary",
+            description="Generate research content summary based on given article outline. dump the outline to the given path. in typst format.",
+            steps=(WriteResearchContentSummary().to_task_output(),),
+        ),
     },
 )
 
@@ -216,21 +220,53 @@ def suma(
     article_path: Path = typer.Option(  # noqa: B008
         Path("article.typ"), "-a", "--article-path", help="Path to the article file."
     ),
-    dump_path: Path = typer.Option(Path("out.typ"), "-d", "--dump-path", help="Path to dump the final output."),  # noqa: B008
+    skip_chapters: List[str] = typer.Option(  # noqa: B008
+        [], "-s", "--skip-chapters", help="Chapters to skip."
+    ),
+    suma_title: str = typer.Option("Chapter Summary", "-t", "--suma-title", help="Title of the chapter summary."),
+    summary_word_count: int = typer.Option(220, "-w", "--word-count", help="Word count for the summary."),
 ) -> None:
     """Write chap summary based on given article."""
-    path = ok(
+    _ = ok(
         asyncio.run(
             Task(name="write an article")
             .update_init_context(
-                article=Article.from_typst_code("article", body=safe_text_read(article_path)),
-                write_to=dump_path,
+                article_path=article_path,
+                summary_title=suma_title,
+                skip_chapters=skip_chapters,
+                summary_word_count=summary_word_count,
             )
             .delegate(ns5)
         ),
         "Failed to generate an article ",
     )
-    logger.success(f"The outline is saved in:\n{path}")
+    logger.success(f"The outline is saved in:\n{article_path.as_posix()}")
+
+
+@app.command()
+def rcsuma(
+    article_path: Path = typer.Option(  # noqa: B008
+        Path("article.typ"), "-a", "--article-path", help="Path to the article file."
+    ),
+    suma_title: str = typer.Option("Research Content", "-t", "--suma-title", help="Title of the summary."),
+    summary_word_count: int = typer.Option(220, "-w", "--word-count", help="Word count for the summary."),
+    paragraph_count: int = typer.Option(1, "-p", "--paragraph-count", help="Number of paragraphs for the summary."),
+) -> None:
+    """Write research summary based on given article."""
+    _ = ok(
+        asyncio.run(
+            Task(name="write an article")
+            .update_init_context(
+                article_path=article_path,
+                summary_title=suma_title,
+                summary_word_count=summary_word_count,
+                paragraph_count=paragraph_count,
+            )
+            .delegate(ns6)
+        ),
+        "Failed to generate an article ",
+    )
+    logger.success(f"The outline is saved in:\n{article_path.as_posix()}")
 
 
 if __name__ == "__main__":

{fabricatio-0.3.14.dev8 → fabricatio-0.3.15.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.3.14-dev8"
+version = "0.3.15-dev4"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }

{fabricatio-0.3.14.dev8 → fabricatio-0.3.15.dev4}/python/fabricatio/actions/article.py

@@ -2,7 +2,7 @@
 
 from asyncio import gather
 from pathlib import Path
-from typing import Callable, List, Optional
+from typing import Callable, ClassVar, List, Optional
 
 from more_itertools import filter_map
 from pydantic import Field
@@ -15,14 +15,14 @@ from fabricatio.fs import dump_text, safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.extra.article_essence import ArticleEssence
-from fabricatio.models.extra.article_main import Article
+from fabricatio.models.extra.article_main import Article, ArticleChapter, ArticleSubsection
 from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.article_proposal import ArticleProposal
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.kwargs_types import ValidateKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.usages import LLMUsage
-from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, BibManager, detect_language
+from fabricatio.rust import CONFIG, TEMPLATE_MANAGER, BibManager, detect_language, word_count
 from fabricatio.utils import ok, wrapp_in_block
 
 
@@ -277,43 +277,139 @@ class LoadArticle(Action):
 class WriteChapterSummary(Action, LLMUsage):
     """Write the chapter summary."""
 
-    output_key: str = "chapter_summaries"
+    ctx_override: ClassVar[bool] = True
 
     paragraph_count: int = 1
+    """The number of paragraphs to generate in the chapter summary."""
 
-    summary_word_count: int = 200
-
+    summary_word_count: int = 120
+    """The number of words to use in each chapter summary."""
+    output_key: str = "summarized_article"
+    """The key under which the summarized article will be stored in the output."""
     summary_title: str = "Chapter Summary"
-    write_to: Optional[Path] = None
+    """The title to be used for the generated chapter summary section."""
+
+    skip_chapters: List[str] = Field(default_factory=list)
+    """A list of chapter titles to skip during summary generation."""
+
+    async def _execute(self, article_path: Path, **cxt) -> Article:
+        article = Article.from_article_file(article_path, article_path.stem)
+
+        chaps = [c for c in article.chapters if c.title not in self.skip_chapters]
+
+        retained_chapters = []
+        # Count chapters before filtering based on section presence,
+        # chaps at this point has already been filtered by self.skip_chapters
+        initial_chaps_for_summary_step_count = len(chaps)
+
+        for chapter_candidate in chaps:
+            if chapter_candidate.sections:  # Check if the sections list is non-empty
+                retained_chapters.append(chapter_candidate)
+            else:
+                # Log c warning for each chapter skipped due to lack of sections
+                logger.warning(
+                    f"Chapter '{chapter_candidate.title}' has no sections and will be skipped for summary generation."
+                )
+
+        chaps = retained_chapters  # Update chaps to only include chapters with sections
 
-    async def _execute(self, article: Article, write_to: Optional[Path] = None, **cxt) -> List[str]:
-        logger.info(";".join(a.title for a in article.chapters))
+        # If chaps is now empty, but there were chapters to consider at the start of this step,
+        # log c specific warning.
+        if not chaps and initial_chaps_for_summary_step_count > 0:
+            raise ValueError("No chapters with sections were found. Please check your input data.")
 
+        # This line was part of the original selection.
+        # It will now log the titles of the chapters that are actually being processed (those with sections).
+        # If 'chaps' is empty, this will result in logger.info(""), which is acceptable.
+        logger.info(";".join(a.title for a in chaps))
         ret = [
-            f"== {self.summary_title}\n{raw}"
+            ArticleSubsection.from_typst_code(self.summary_title, raw)
             for raw in (
                 await self.aask(
                     TEMPLATE_MANAGER.render_template(
                         CONFIG.templates.chap_summary_template,
                         [
                             {
-                                "chapter": a.to_typst_code(),
-                                "title": a.title,
-                                "language": a.language,
+                                "chapter": c.to_typst_code(),
+                                "title": c.title,
+                                "language": c.language,
                                 "summary_word_count": self.summary_word_count,
                                 "paragraph_count": self.paragraph_count,
                             }
-                            for a in article.chapters
+                            for c in chaps
                         ],
                     )
                 )
             )
         ]
 
-        if (to := (self.write_to or write_to)) is not None:
-            dump_text(
-                to,
-                "\n\n\n".join(f"//{a.title}\n\n{s}" for a, s in zip(article.chapters, ret, strict=True)),
+        for c, n in zip(chaps, ret, strict=True):
+            c: ArticleChapter
+            n: ArticleSubsection
+            if c.sections[-1].title == self.summary_title:
+                logger.debug(f"Removing old summary `{self.summary_title}` at {c.title}")
+                c.sections.pop()
+
+            c.sections[-1].subsections.append(n)
+
+        article.update_article_file(article_path)
+
+        dump_text(
+            article_path, safe_text_read(article_path).replace(f"=== {self.summary_title}", f"== {self.summary_title}")
+        )
+        return article
+
+
+class WriteResearchContentSummary(Action, LLMUsage):
+    """Write the research content summary."""
+
+    ctx_override: ClassVar[bool] = True
+    summary_word_count: int = 160
+    """The number of words to use in the research content summary."""
+
+    output_key: str = "summarized_article"
+    """The key under which the summarized article will be stored in the output."""
+
+    summary_title: str = "Research Content"
+    """The title to be used for the generated research content summary section."""
+
+    paragraph_count: int = 1
+    """The number of paragraphs to generate in the research content summary."""
+
+    async def _execute(self, article_path: Path, **cxt) -> Article:
+        article = Article.from_article_file(article_path, article_path.stem)
+        if not article.chapters:
+            raise ValueError("No chapters found in the article.")
+        chap_1 = article.chapters[0]
+        if not chap_1.sections:
+            raise ValueError("No sections found in the first chapter of the article.")
+
+        outline = article.extrac_outline()
+        suma: str = await self.aask(
+            TEMPLATE_MANAGER.render_template(
+                CONFIG.templates.research_content_summary_template,
+                {
+                    "title": outline.title,
+                    "outline": outline.to_typst_code(),
+                    "language": detect_language(self.summary_title),
+                    "summary_word_count": self.summary_word_count,
+                    "paragraph_count": self.paragraph_count,
+                },
             )
+        )
+        logger.success(
+            f"{self.summary_title}|Wordcount: {word_count(suma)}|Expected: {self.summary_word_count}\n{suma}"
+        )
+
+        if chap_1.sections[-1].title == self.summary_title:
+            # remove old
+            logger.debug(f"Removing old summary `{self.summary_title}`")
+            chap_1.sections.pop()
 
-        return ret
+        chap_1.sections[-1].subsections.append(ArticleSubsection.from_typst_code(self.summary_title, suma))
+
+        article.update_article_file(article_path)
+        dump_text(
+            article_path, safe_text_read(article_path).replace(f"=== {self.summary_title}", f"== {self.summary_title}")
+        )
+        return article

{fabricatio-0.3.14.dev8 → fabricatio-0.3.15.dev4}/python/fabricatio/models/extra/article_base.py

@@ -21,7 +21,15 @@ from fabricatio.models.generic import (
     Titled,
     WordCount,
 )
-from fabricatio.rust import extract_body, replace_thesis_body, split_out_metadata, to_metadata, word_count
+from fabricatio.rust import (
+    detect_language,
+    extract_body,
+    replace_thesis_body,
+    split_out_metadata,
+    strip_comment,
+    to_metadata,
+    word_count,
+)
 from fabricatio.utils import fallback_kwargs, ok
 from pydantic import Field
 
@@ -52,10 +60,31 @@ class ArticleMetaData(SketchedAble, Described, WordCount, Titled, Language):
     aims: List[str]
     """List of writing aims of the research component in academic style."""
 
+    _unstructured_body: str = ""
+    """Store the source of the unknown information."""
+
     @property
     def typst_metadata_comment(self) -> str:
         """Generates a comment for the metadata of the article component."""
-        return to_metadata(self.model_dump(include={"description", "aims", "expected_word_count"}, by_alias=True))
+        data = self.model_dump(
+            include={"description", "aims", "expected_word_count"},
+            by_alias=True,
+        )
+        return to_metadata({k: v for k, v in data.items() if v})
+
+    @property
+    def unstructured_body(self) -> str:
+        """Returns the unstructured body of the article component."""
+        return self._unstructured_body
+
+    def update_unstructured_body[S: "ArticleMetaData"](self: S, body: str) -> S:
+        """Update the unstructured body of the article component."""
+        self._unstructured_body = body
+        return self
+
+    @property
+    def language(self) -> str:
+        return detect_language(self.title)
 
 
 class FromTypstCode(ArticleMetaData):
@@ -67,13 +96,8 @@ class FromTypstCode(ArticleMetaData):
         data, body = split_out_metadata(body)
 
         return cls(
-            heading=title,
-            **fallback_kwargs(
-                data or {},
-                elaboration="",
-                expected_word_count=word_count(body),
-                aims=[],
-            ),
+            heading=title.strip(),
+            **fallback_kwargs(data or {}, elaboration="", expected_word_count=word_count(body), aims=[]),
             **kwargs,
         )
 
@@ -83,7 +107,7 @@ class ToTypstCode(ArticleMetaData):
 
     def to_typst_code(self) -> str:
         """Converts the component into a Typst code snippet for rendering."""
-        return f"{self.title}\n{self.typst_metadata_comment}\n"
+        return f"{self.title}\n{self.typst_metadata_comment}\n\n{self._unstructured_body}"
 
 
 class ArticleOutlineBase(
@@ -151,12 +175,16 @@ class SectionBase[T: SubSectionBase](ArticleOutlineBase):
     @classmethod
     def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Creates an Article object from the given Typst code."""
-        return super().from_typst_code(
-            title,
-            body,
-            subsections=[
-                cls.child_type.from_typst_code(*pack) for pack in extract_sections(body, level=3, section_char="=")
-            ],
+        raw = extract_sections(body, level=3, section_char="=")
+
+        return (
+            super()
+            .from_typst_code(
+                title,
+                body,
+                subsections=[cls.child_type.from_typst_code(*pack) for pack in raw],
+            )
+            .update_unstructured_body("" if raw else strip_comment(body))
         )
 
     def resolve_update_conflict(self, other: Self) -> str:
@@ -191,6 +219,11 @@ class SectionBase[T: SubSectionBase](ArticleOutlineBase):
             return f"Section `{self.title}` contains no subsections, expected at least one, but got 0, you can add one or more as needed."
         return ""
 
+    @property
+    def exact_word_count(self) -> int:
+        """Returns the exact word count of the article section outline."""
+        return sum(a.exact_word_count for a in self.subsections)
+
 
 class ChapterBase[T: SectionBase](ArticleOutlineBase):
     """Base class for article chapters."""
@@ -206,12 +239,16 @@ class ChapterBase[T: SectionBase](ArticleOutlineBase):
     @classmethod
     def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Creates an Article object from the given Typst code."""
-        return super().from_typst_code(
-            title,
-            body,
-            sections=[
-                cls.child_type.from_typst_code(*pack) for pack in extract_sections(body, level=2, section_char="=")
-            ],
+        raw_sec = extract_sections(body, level=2, section_char="=")
+
+        return (
+            super()
+            .from_typst_code(
+                title,
+                body,
+                sections=[cls.child_type.from_typst_code(*pack) for pack in raw_sec],
+            )
+            .update_unstructured_body("" if raw_sec else strip_comment(body))
         )
 
     def resolve_update_conflict(self, other: Self) -> str:
@@ -243,6 +280,15 @@ class ChapterBase[T: SectionBase](ArticleOutlineBase):
             return f"Chapter `{self.title}` contains no sections, expected at least one, but got 0, you can add one or more as needed."
         return ""
 
+    @property
+    def exact_word_count(self) -> int:
+        """Calculates the total word count across all sections in the chapter.
+
+        Returns:
+            int: The cumulative word count of all sections.
+        """
+        return sum(a.exact_word_count for a in self.sections)
+
 
 class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, FromTypstCode, ToTypstCode, ABC):
     """Base class for article outlines."""
@@ -263,15 +309,33 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, FromTypstCode, To
 
     child_type: ClassVar[Type[ChapterBase]]
 
+    @property
+    def language(self) -> str:
+        if self.title:
+            return super().language
+        return self.chapters[0].language
+
+    @property
+    def exact_word_count(self) -> int:
+        """Calculates the total word count across all chapters in the article.
+
+        Returns:
+            int: The cumulative word count of all chapters.
+        """
+        return sum(ch.exact_word_count for ch in self.chapters)
+
     @classmethod
     def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Generates an article from the given Typst code."""
-        return super().from_typst_code(
-            title,
-            body,
-            chapters=[
-                cls.child_type.from_typst_code(*pack) for pack in extract_sections(body, level=1, section_char="=")
-            ],
+        raw = extract_sections(body, level=1, section_char="=")
+        return (
+            super()
+            .from_typst_code(
+                title,
+                body,
+                chapters=[cls.child_type.from_typst_code(*pack) for pack in raw],
+            )
+            .update_unstructured_body("" if raw else strip_comment(body))
         )
 
     def iter_dfs_rev(
@@ -350,7 +414,7 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, FromTypstCode, To
 
     def to_typst_code(self) -> str:
         """Generates the Typst code representation of the article."""
-        return f"// #{super().to_typst_code()}\n\n" + "\n\n".join(a.to_typst_code() for a in self.chapters)
+        return f"// #Title: {super().to_typst_code()}\n" + "\n\n".join(a.to_typst_code() for a in self.chapters)
 
     def finalized_dump(self) -> str:
         """Generates standardized hierarchical markup for academic publishing systems.
@@ -401,11 +465,11 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, FromTypstCode, To
         """Set all chap, sec, subsec have same word count sum up to be `self.expected_word_count`."""
         return self.avg_chap_wordcount().avg_sec_wordcount().avg_subsec_wordcount()
 
-    def update_article_file(self, file: str | Path) -> Self:
+    def update_article_file[S: "ArticleBase"](self: S, file: str | Path) -> S:
         """Update the article file."""
         file = Path(file)
         string = safe_text_read(file)
-        if updated := replace_thesis_body(string, ARTICLE_WRAPPER, self.to_typst_code()):
+        if updated := replace_thesis_body(string, ARTICLE_WRAPPER, f"\n\n{self.to_typst_code()}\n\n"):
             dump_text(file, updated)
             logger.success(f"Successfully updated {file.as_posix()}.")
         else:
@@ -413,7 +477,7 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, FromTypstCode, To
         return self
 
     @classmethod
-    def from_article_file[S: "ArticleBase"](cls: Type[S], file: str | Path, title: str) -> S:
+    def from_article_file[S: "ArticleBase"](cls: Type[S], file: str | Path, title: str = "") -> S:
         """Load article from file."""
         file = Path(file)
         string = safe_text_read(file)