fabricatio 0.2.9.dev3__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.10__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/actions/article.py

@@ -11,7 +11,6 @@ from fabricatio.capabilities.propose import Propose
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.extra.article_base import SubSectionBase
 from fabricatio.models.extra.article_essence import ArticleEssence
 from fabricatio.models.extra.article_main import Article
 from fabricatio.models.extra.article_outline import ArticleOutline
@@ -79,7 +78,7 @@ class FixArticleEssence(Action):
         out = []
         count = 0
         for a in article_essence:
-            if key := (bib_mgr.get_cite_key(a.title) or bib_mgr.get_cite_key_fuzzy(a.title)):
+            if key := (bib_mgr.get_cite_key_by_title(a.title) or bib_mgr.get_cite_key_fuzzy(a.title)):
                 a.title = bib_mgr.get_title_by_key(key) or a.title
                 a.authors = bib_mgr.get_author_by_key(key) or a.authors
                 a.publication_year = bib_mgr.get_year_by_key(key) or a.publication_year
@@ -105,7 +104,6 @@ class GenerateArticleProposal(Action, Propose):
         task_input: Optional[Task] = None,
         article_briefing: Optional[str] = None,
         article_briefing_path: Optional[str] = None,
-        langauge: Optional[str] = None,
         **_,
     ) -> Optional[ArticleProposal]:
         if article_briefing is None and article_briefing_path is None and task_input is None:
@@ -122,17 +120,14 @@ class GenerateArticleProposal(Action, Propose):
             )
         )
 
-        proposal = ok(
+        logger.info("Start generating the proposal.")
+        return ok(
             await self.propose(
                 ArticleProposal,
-                f"{briefing}\n\nWrite the value string using `{detect_language(briefing)}`",
+                f"{briefing}\n\nWrite the value string using `{detect_language(briefing)}` as written language.",
             ),
             "Could not generate the proposal.",
         ).update_ref(briefing)
-        if langauge:
-            proposal.language = langauge
-
-        return proposal
 
 
 class GenerateInitialOutline(Action, Propose):
@@ -146,11 +141,18 @@ class GenerateInitialOutline(Action, Propose):
         article_proposal: ArticleProposal,
         **_,
     ) -> Optional[ArticleOutline]:
+        raw_outline = await self.aask(
+            f"{(article_proposal.as_prompt())}\n\nNote that you should use `{article_proposal.language}` to write the `ArticleOutline`\n"
+            f"Design each chapter of a proper and academic and ready for release manner.\n"
+            f"You Must make sure every chapter have sections, and every section have subsections.\n"
+            f"Make the chapter and sections and subsections bing divided into a specific enough article component.\n"
+            f"Every chapter must have sections, every section must have subsections.",
+        )
+
         return ok(
             await self.propose(
                 ArticleOutline,
-                f"{(p := article_proposal.as_prompt())}\n\nNote that you should use `{detect_language(p)}` to write the `ArticleOutline`\n"
-                f"You Must make sure every chapter have sections, and every section have subsections.",
+                f"{raw_outline}\n\n\n\noutline provided above is the outline i need to extract to a JSON,",
             ),
             "Could not generate the initial outline.",
         ).update_ref(article_proposal)
@@ -182,7 +184,7 @@ class FixIntrospectedErrors(Action, Censor):
                 await self.censor_obj(
                     article_outline,
                     ruleset=ok(intro_fix_ruleset or self.ruleset, "No ruleset provided"),
-                    reference=f"{article_outline.as_prompt()}\n # Fatal Error of the Original Article Outline\n{pack}",
+                    reference=f"{article_outline.display()}\n # Fatal Error of the Original Article Outline\n{pack}",
                 ),
                 "Could not correct the component.",
             ).update_ref(origin)
@@ -195,107 +197,6 @@ class FixIntrospectedErrors(Action, Censor):
         return article_outline
 
 
-class FixIllegalReferences(Action, Censor):
-    """Fix illegal references in the article outline."""
-
-    output_key: str = "illegal_references_fixed_outline"
-    """The key of the output data."""
-
-    ruleset: Optional[RuleSet] = None
-    """Ruleset to use to fix the illegal references."""
-    max_error_count: Optional[int] = None
-    """The maximum number of errors to fix."""
-
-    async def _execute(
-        self,
-        article_outline: ArticleOutline,
-        ref_fix_ruleset: Optional[RuleSet] = None,
-        **_,
-    ) -> Optional[ArticleOutline]:
-        counter = 0
-        while pack := article_outline.find_illegal_ref(gather_identical=True):
-            logger.info(f"Found {counter}th illegal references")
-            ref_seq, err = ok(pack)
-            logger.warning(f"Found illegal referring error: {err}")
-            new = ok(
-                await self.censor_obj(
-                    ref_seq[0],
-                    ruleset=ok(ref_fix_ruleset or self.ruleset, "No ruleset provided"),
-                    reference=f"{article_outline.as_prompt()}\n# Some Basic errors found that need to be fixed\n{err}",
-                ),
-                "Could not correct the component",
-            )
-            for r in ref_seq:
-                r.update_from(new)
-            if self.max_error_count and counter > self.max_error_count:
-                logger.warning("Max error count reached, stopping.")
-                break
-            counter += 1
-
-        return article_outline
-
-
-class TweakOutlineForwardRef(Action, Censor):
-    """Tweak the forward references in the article outline.
-
-    Ensures that the conclusions of the current chapter effectively support the analysis of subsequent chapters.
-    """
-
-    output_key: str = "article_outline_fw_ref_checked"
-    ruleset: Optional[RuleSet] = None
-    """Ruleset to use to fix the illegal references."""
-
-    async def _execute(
-        self, article_outline: ArticleOutline, ref_twk_ruleset: Optional[RuleSet] = None, **cxt
-    ) -> ArticleOutline:
-        return await self._inner(
-            article_outline,
-            ruleset=ok(ref_twk_ruleset or self.ruleset, "No ruleset provided"),
-            field_name="support_to",
-        )
-
-    async def _inner(self, article_outline: ArticleOutline, ruleset: RuleSet, field_name: str) -> ArticleOutline:
-        await gather(
-            *[self._loop(a[-1], article_outline, field_name, ruleset) for a in article_outline.iter_subsections()],
-        )
-
-        return article_outline
-
-    async def _loop(
-        self, a: SubSectionBase, article_outline: ArticleOutline, field_name: str, ruleset: RuleSet
-    ) -> None:
-        if judge := await self.evidently_judge(
-            f"{article_outline.as_prompt()}\n\n{a.display()}\n"
-            f"Does the `{a.__class__.__name__}`'s `{field_name}` field need to be extended or tweaked?"
-        ):
-            await self.censor_obj_inplace(
-                a,
-                ruleset=ruleset,
-                reference=f"{article_outline.as_prompt()}\n"
-                f"The Article component titled `{a.title}` whose `{field_name}` field needs to be extended or tweaked.\n"
-                f"# Judgement\n{judge.display()}",
-            )
-
-
-class TweakOutlineBackwardRef(TweakOutlineForwardRef):
-    """Tweak the backward references in the article outline.
-
-    Ensures that the prerequisites of the current chapter are correctly referenced in the `depend_on` field.
-    """
-
-    output_key: str = "article_outline_bw_ref_checked"
-    ruleset: Optional[RuleSet] = None
-
-    async def _execute(
-        self, article_outline: ArticleOutline, ref_twk_ruleset: Optional[RuleSet] = None, **cxt
-    ) -> ArticleOutline:
-        return await self._inner(
-            article_outline,
-            ruleset=ok(ref_twk_ruleset or self.ruleset, "No ruleset provided"),
-            field_name="depend_on",
-        )
-
-
 class GenerateArticle(Action, Censor):
     """Generate the article based on the outline."""
 
@@ -318,7 +219,7 @@ class GenerateArticle(Action, Censor):
                 self.censor_obj_inplace(
                     subsec,
                     ruleset=ok(article_gen_ruleset or self.ruleset, "No ruleset provided"),
-                    reference=f"{article_outline.as_prompt()}\n# Error Need to be fixed\n{err}",
+                    reference=f"{article_outline.as_prompt()}\n# Error Need to be fixed\n{err}\nYou should use `{subsec.language}` to write the new `Subsection`.",
                 )
                 for _, _, subsec in article.iter_subsections()
                 if (err := subsec.introspect()) and logger.warning(f"Found Introspection Error:\n{err}") is None
@@ -326,3 +227,12 @@ class GenerateArticle(Action, Censor):
         )
 
         return article
+
+
+class LoadArticle(Action):
+    """Load the article from the outline and typst code."""
+
+    output_key: str = "loaded_article"
+
+    async def _execute(self, article_outline: ArticleOutline, typst_code: str, **cxt) -> Article:
+        return Article.from_mixed_source(article_outline, typst_code)

fabricatio/actions/article_rag.py

@@ -1,14 +1,122 @@
 """A module for writing articles using RAG (Retrieval-Augmented Generation) capabilities."""
 
 from asyncio import gather
-from typing import Optional
+from pathlib import Path
+from typing import List, Optional
 
+from fabricatio import BibManager
 from fabricatio.capabilities.censor import Censor
+from fabricatio.capabilities.propose import Propose
 from fabricatio.capabilities.rag import RAG
+from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.extra.article_main import Article, ArticleSubsection
+from fabricatio.models.extra.aricle_rag import ArticleChunk
+from fabricatio.models.extra.article_essence import ArticleEssence
+from fabricatio.models.extra.article_main import Article, ArticleChapter, ArticleSection, ArticleSubsection
+from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.rule import RuleSet
-from fabricatio.utils import ok
+from fabricatio.utils import ok, replace_brackets
+
+
+class WriteArticleContentRAG(Action, RAG, Propose):
+    """Write an article based on the provided outline."""
+
+    ref_limit: int = 100
+    """The limit of references to be retrieved"""
+    extractor_model: str
+    """The model to use for extracting the content from the retrieved references."""
+    query_model: str
+    """The model to use for querying the database"""
+
+    async def _execute(
+            self,
+            article_outline: ArticleOutline,
+            writing_ruleset: RuleSet,
+            collection_name: str = "article_chunks",
+            **cxt,
+    ) -> Article:
+        article = Article.from_outline(article_outline).update_ref(article_outline)
+        await gather(
+            *[
+                self._inner(article, article_outline, chap, sec, subsec)
+                for chap, sec, subsec in article.iter_subsections()
+            ]
+        )
+        return article.convert_tex()
+
+    async def _inner(
+            self,
+            article: Article,
+            article_outline: ArticleOutline,
+            chap: ArticleChapter,
+            sec: ArticleSection,
+            subsec: ArticleSubsection,
+    ) -> ArticleSubsection:
+        ref_q = ok(
+            await self.arefined_query(
+                f"{article_outline.display()}\n\nAbove is my article outline, I m writing graduate thesis titled `{article.title}`. "
+                f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
+                f"I need to search related references to build up the content of the subsec mentioned above, which is `{subsec.title}`.\n"
+                f"plus, you can search required formulas by using latex equation code.\n"
+                f"provide 10 queries as possible, to get best result!\n"
+                f"You should provide both English version and chinese version of the refined queries!\n",
+                model=self.query_model
+            ),
+            "Failed to refine query.",
+        )
+        ret = await self.aretrieve(ref_q, ArticleChunk, final_limit=self.ref_limit, result_per_query=25)
+        ret.reverse()
+        for i, r in enumerate(ret):
+            r.update_cite_number(i)
+        raw_paras = await self.aask(
+            "\n".join(r.as_prompt() for r in ret)
+            + "Above is some related reference retrieved for you. When need to cite some of them ,you MUST follow the academic convention,"
+              f"{article.referenced.display()}\n\nAbove is my article outline, I m writing graduate thesis titled `{article.title}`. "
+              f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
+              f"Please help me write the paragraphs of the subsec mentioned above, which is `{subsec.title}`\n"
+              f"You can output the written paragraphs directly, without explanation. you should use `{subsec.language}`, and maintain academic writing style."
+              f"In addition,you MUST follow the academic convention and use [[1]] to cite the first reference, and use [[9]] to cite the second reference, and so on.\n"
+              f"It 's greatly recommended to cite multiple references that stands for the same opinion at a single sentences, like [[1,5,9]] for 1th,5th and 9th references,[[1-9,16]] for 1th to 9th and 16th references.\n"
+              f"citation number is REQUIRED to cite any reference!\n"
+              f"for paragraphs that need write equation you should also no forget to doing so. wrapp inline equation using $ $, and wrapp block equation using $$ $$.\n"
+        )
+
+        raw_paras = (raw_paras
+                     .replace(r" \( ", "$")
+                     .replace(r" \) ", "$")
+                     .replace("\\[\n", "$$\n")
+                     .replace("\n\\]", "\n$$"))
+
+        new_subsec = ok(
+            await self.propose(
+                ArticleSubsection,
+                f"{raw_paras}\nAbove is the subsection titled `{subsec.title}`.\n"
+                f"I need you to extract the content to update my subsection obj provided below.\n"
+                f"Everything is build upon the typst language, which is similar to latex, \n"
+                f"so reference annotation like `[[1]]` for 1th reference or `[[2,6]]` for 2th and 6th reference or "
+                f"`[[1,5,9]]` for 1th,5th and 9th references or "
+                f"`[[1-9,16]]` for 1th to 9th and 16th references\n"
+                f"Those reference mark shall not be omitted during the extraction\n"
+                f"Wrapp inline expression using $ $, and wrapp block equation using $$ $$\n\n\n"
+                f"{subsec.display()}",
+                model=self.extractor_model,
+            ),
+            "Failed to propose new subsection.",
+        )
+
+        logger.debug(f"{subsec.title}:new\n{new_subsec.display()}")
+
+        for p in new_subsec.paragraphs:
+            p.content = replace_brackets(p.content)
+        logger.debug(f"{subsec.title}:rb\n{new_subsec.display()}")
+
+        for r in ret:
+            new_subsec = r.apply(new_subsec)
+        logger.debug(f"{subsec.title}:rnm\n{new_subsec.display()}")
+
+        subsec.update_from(new_subsec)
+        logger.debug(f"{subsec.title}:rpl\n{subsec.display()}")
+        return subsec
 
 
 class TweakArticleRAG(Action, RAG, Censor):
@@ -29,14 +137,17 @@ class TweakArticleRAG(Action, RAG, Censor):
     ruleset: Optional[RuleSet] = None
     """The ruleset to be used for censoring the article."""
 
+    ref_limit: int = 30
+    """The limit of references to be retrieved"""
+
     async def _execute(
-        self,
-        article: Article,
-        collection_name: str = "article_essence",
-        twk_rag_ruleset: Optional[RuleSet] = None,
-        parallel: bool = False,
-        **cxt,
-    ) -> Optional[Article]:
+            self,
+            article: Article,
+            collection_name: str = "article_essence",
+            twk_rag_ruleset: Optional[RuleSet] = None,
+            parallel: bool = False,
+            **cxt,
+    ) -> Article:
         """Write an article based on the provided outline.
 
         This method processes the article outline, either in parallel or sequentially, by enhancing each subsection
@@ -50,7 +161,7 @@ class TweakArticleRAG(Action, RAG, Censor):
             **cxt: Additional context parameters.
 
         Returns:
-            Optional[Article]: The processed article with enhanced subsections and applied censoring rules.
+            Article: The processed article with enhanced subsections and applied censoring rules.
         """
         self.view(collection_name)
 
@@ -83,16 +194,43 @@ class TweakArticleRAG(Action, RAG, Censor):
         """
         refind_q = ok(
             await self.arefined_query(
-                f"{article.referenced.as_prompt()}\n"
-                f"# Subsection requiring reference enhancement\n"
-                f"{subsec.display()}\n"
-                f"# Requirement\n"
-                f"Search related articles in the base to find reference candidates, "
-                f"prioritizing both original article language and English usage, which can return multiple candidates.",
+                f"{article.referenced.as_prompt()}\n# Subsection requiring reference enhancement\n{subsec.display()}\n"
             )
         )
         await self.censor_obj_inplace(
             subsec,
             ruleset=ruleset,
-            reference=await self.aretrieve_compact(refind_q, final_limit=30),
+            reference=f"{'\n\n'.join(d.display() for d in await self.aretrieve(refind_q, document_model=ArticleEssence, final_limit=self.ref_limit))}\n\n"
+                      f"You can use Reference above to rewrite the `{subsec.__class__.__name__}`.\n"
+                      f"You should Always use `{subsec.language}` as written language, "
+                      f"which is the original language of the `{subsec.title}`. "
+                      f"since rewrite a `{subsec.__class__.__name__}` in a different language is usually a bad choice",
+        )
+
+
+class ChunkArticle(Action):
+    """Chunk an article into smaller chunks."""
+
+    output_key: str = "article_chunks"
+    """The key used to store the output of the action."""
+    max_chunk_size: Optional[int] = None
+    """The maximum size of each chunk."""
+    max_overlapping_rate: Optional[float] = None
+    """The maximum overlapping rate between chunks."""
+
+    async def _execute(
+            self,
+            article_path: str | Path,
+            bib_manager: BibManager,
+            max_chunk_size: Optional[int] = None,
+            max_overlapping_rate: Optional[float] = None,
+            **_,
+    ) -> List[ArticleChunk]:
+        return ArticleChunk.from_file(
+            article_path,
+            bib_manager,
+            max_chunk_size=ok(max_chunk_size or self.max_chunk_size, "No max_chunk_size provided!"),
+            max_overlapping_rate=ok(
+                max_overlapping_rate or self.max_overlapping_rate, "No max_overlapping_rate provided!"
+            ),
         )

fabricatio/actions/fs.py

@@ -0,0 +1,25 @@
+"""A module for file system utilities."""
+
+from pathlib import Path
+from typing import Any, List, Mapping, Self
+
+from fabricatio.fs import safe_text_read
+from fabricatio.journal import logger
+from fabricatio.models.action import Action
+from fabricatio.models.generic import FromMapping
+
+
+class ReadText(Action, FromMapping):
+    """Read text from a file."""
+    output_key: str = "read_text"
+    read_path: str | Path
+    """Path to the file to read."""
+
+    async def _execute(self, *_: Any, **cxt) -> str:
+        logger.info(f"Read text from {Path(self.read_path).as_posix()} to {self.output_key}")
+        return safe_text_read(self.read_path)
+
+    @classmethod
+    def from_mapping(cls, mapping: Mapping[str, str | Path], **kwargs: Any) -> List[Self]:
+        """Create a list of ReadText actions from a mapping of output_key to read_path."""
+        return [cls(read_path=p, output_key=k, **kwargs) for k, p in mapping.items()]

fabricatio/actions/output.py

@@ -1,11 +1,11 @@
 """Dump the finalized output to a file."""
 
 from pathlib import Path
-from typing import Any, Iterable, List, Optional, Type
+from typing import Any, Iterable, List, Mapping, Optional, Type
 
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.generic import FinalizedDumpAble, PersistentAble
+from fabricatio.models.generic import FinalizedDumpAble, FromMapping, PersistentAble
 from fabricatio.models.task import Task
 from fabricatio.utils import ok
 
@@ -115,7 +115,7 @@ class RetrieveFromPersistent[T: PersistentAble](Action):
         return self.retrieve_cls.from_persistent(self.load_path)
 
 
-class RetrieveFromLatest[T: PersistentAble](RetrieveFromPersistent[T]):
+class RetrieveFromLatest[T: PersistentAble](RetrieveFromPersistent[T], FromMapping):
     """Retrieve the object from the latest persistent file in the dir at `load_path`."""
 
     async def _execute(self, /, **_) -> Optional[T]:
@@ -130,6 +130,20 @@ class RetrieveFromLatest[T: PersistentAble](RetrieveFromPersistent[T]):
         logger.error(f"Path {self.load_path} is not a directory")
         return None
 
+    @classmethod
+    def from_mapping(
+        cls,
+        mapping: Mapping[str, str | Path],
+        *,
+        retrieve_cls: Type[T],
+        **kwargs,
+    ) -> List["RetrieveFromLatest[T]"]:
+        """Create a list of `RetrieveFromLatest` from the mapping."""
+        return [
+            cls(retrieve_cls=retrieve_cls, load_path=Path(p).as_posix(), output_key=o, **kwargs)
+            for o, p in mapping.items()
+        ]
+
 
 class GatherAsList(Action):
     """Gather the objects from the context as a list.

fabricatio/actions/rag.py

@@ -5,34 +5,56 @@ from typing import List, Optional
 from questionary import text
 
 from fabricatio.capabilities.rag import RAG
+from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.generic import Vectorizable
+from fabricatio.models.extra.rag import MilvusClassicModel, MilvusDataBase
 from fabricatio.models.task import Task
+from fabricatio.utils import ok
 
 
 class InjectToDB(Action, RAG):
     """Inject data into the database."""
 
     output_key: str = "collection_name"
+    collection_name: str = "my_collection"
+    """The name of the collection to inject data into."""
 
-    async def _execute[T: Vectorizable](
-        self, to_inject: Optional[T] | List[Optional[T]], collection_name: str = "my_collection",override_inject:bool=False, **_
+    async def _execute[T: MilvusDataBase](
+        self, to_inject: Optional[T] | List[Optional[T]], override_inject: bool = False, **_
     ) -> Optional[str]:
+        from pymilvus.milvus_client import IndexParams
+
+        if to_inject is None:
+            return None
         if not isinstance(to_inject, list):
             to_inject = [to_inject]
-        logger.info(f"Injecting {len(to_inject)} items into the collection '{collection_name}'")
+        if not (seq := [t for t in to_inject if t is not None]):  # filter out None
+            return None
+        logger.info(f"Injecting {len(seq)} items into the collection '{self.collection_name}'")
         if override_inject:
-            self.check_client().client.drop_collection(collection_name)
-        await self.view(collection_name, create=True).consume_string(
-            [
-                t.prepare_vectorization(self.embedding_max_sequence_length)
-                for t in to_inject
-                if isinstance(t, Vectorizable)
-            ],
-        )
-
-        return collection_name
+            self.check_client().client.drop_collection(self.collection_name)
+
+        await self.view(
+            self.collection_name,
+            create=True,
+            schema=seq[0].as_milvus_schema(
+                ok(
+                    self.milvus_dimensions
+                    or configs.rag.milvus_dimensions
+                    or self.embedding_dimensions
+                    or configs.embedding.dimensions
+                ),
+            ),
+            index_params=IndexParams(
+                seq[0].vector_field_name,
+                index_name=seq[0].vector_field_name,
+                index_type=seq[0].index_type,
+                metric_type=seq[0].metric_type,
+            ),
+        ).add_document(seq, flush=True)
+
+        return self.collection_name
 
 
 class RAGTalk(Action, RAG):
@@ -62,10 +84,10 @@ class RAGTalk(Action, RAG):
                 user_say = await text("User: ").ask_async()
                 if user_say is None:
                     break
-                gpt_say = await self.aask_retrieved(
-                    user_say,
-                    user_say,
-                    extra_system_message=f"You have to answer to user obeying task assigned to you:\n{task_input.briefing}",
+                ret: List[MilvusClassicModel] = await self.aretrieve(user_say, document_model=MilvusClassicModel)
+
+                gpt_say = await self.aask(
+                    user_say, system_message="\n".join(m.text for m in ret) + "\nYou can refer facts provided above."
                 )
                 print(f"GPT: {gpt_say}")  # noqa: T201
                 counter += 1

fabricatio/actions/rules.py

@@ -1,15 +1,16 @@
 """A module containing the DraftRuleSet action."""
 
-from typing import List, Optional
+from typing import Any, List, Mapping, Optional, Self, Tuple
 
 from fabricatio.capabilities.check import Check
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.extra.rule import RuleSet
+from fabricatio.models.generic import FromMapping
 from fabricatio.utils import ok
 
 
-class DraftRuleSet(Action, Check):
+class DraftRuleSet(Action, Check, FromMapping):
     """Action to draft a ruleset based on a given requirement description."""
 
     output_key: str = "drafted_ruleset"
@@ -45,8 +46,13 @@ class DraftRuleSet(Action, Check):
             logger.warning(f"Drafting Rule Failed for:\n{ruleset_requirement}")
         return ruleset
 
+    @classmethod
+    def from_mapping(cls, mapping: Mapping[str, Tuple[int, str]], **kwargs) -> List[Self]:
+        """Create a list of DraftRuleSet actions from a mapping of output keys to tuples of rule counts and requirements."""
+        return [cls(ruleset_requirement=r, rule_count=c, output_key=k, **kwargs) for k, (c, r) in mapping.items()]
 
-class GatherRuleset(Action):
+
+class GatherRuleset(Action, FromMapping):
     """Action to gather a ruleset from a given requirement description."""
 
     output_key: str = "gathered_ruleset"
@@ -55,6 +61,11 @@ class GatherRuleset(Action):
     to_gather: List[str]
     """the cxt name of RuleSet to gather"""
 
+    @classmethod
+    def from_mapping(cls, mapping: Mapping[str, List[str]], **kwargs: Any) -> List[Self]:
+        """Create a list of GatherRuleset actions from a mapping of output keys to tuples of rule counts and requirements."""
+        return [cls(to_gather=t, output_key=k, **kwargs) for k, t in mapping.items()]
+
     async def _execute(self, **cxt) -> RuleSet:
         logger.info(f"Gathering Ruleset from {self.to_gather}")
         # Fix for not_found

fabricatio/capabilities/check.py

@@ -8,7 +8,7 @@ from fabricatio.capabilities.advanced_judge import AdvancedJudge
 from fabricatio.capabilities.propose import Propose
 from fabricatio.config import configs
 from fabricatio.journal import logger
-from fabricatio.models.extra.patches import RuleSetBriefingPatch
+from fabricatio.models.extra.patches import RuleSetMetadata
 from fabricatio.models.extra.problem import Improvement
 from fabricatio.models.extra.rule import Rule, RuleSet
 from fabricatio.models.generic import Display, WithBriefing
@@ -42,12 +42,17 @@ class Check(AdvancedJudge, Propose):
             - Returns None if any step in rule generation fails
             - Uses `alist_str` for requirement breakdown and iterative rule proposal
         """
-        rule_reqs = await self.alist_str(
-            TEMPLATE_MANAGER.render_template(
-                configs.templates.ruleset_requirement_breakdown_template, {"ruleset_requirement": ruleset_requirement}
-            ),
-            rule_count,
-            **override_kwargs(kwargs, default=None),
+        rule_reqs = (
+            await self.alist_str(
+                TEMPLATE_MANAGER.render_template(
+                    configs.templates.ruleset_requirement_breakdown_template,
+                    {"ruleset_requirement": ruleset_requirement},
+                ),
+                rule_count,
+                **override_kwargs(kwargs, default=None),
+            )
+            if rule_count > 1
+            else [ruleset_requirement]
         )
 
         if rule_reqs is None:
@@ -65,7 +70,7 @@ class Check(AdvancedJudge, Propose):
             return None
 
         ruleset_patch = await self.propose(
-            RuleSetBriefingPatch,
+            RuleSetMetadata,
             f"{ruleset_requirement}\n\nYou should use `{detect_language(ruleset_requirement)}`!",
             **override_kwargs(kwargs, default=None),
         )
@@ -99,7 +104,8 @@ class Check(AdvancedJudge, Propose):
             - Proposes Improvement only when violation is confirmed
         """
         if judge := await self.evidently_judge(
-            f"# Content to exam\n{input_text}\n\n# Rule Must to follow\n{rule.display()}\nDoes `Content to exam` provided above violate the `Rule Must to follow` provided above?",
+            f"# Content to exam\n{input_text}\n\n# Rule Must to follow\n{rule.display()}\nDoes `Content to exam` provided above violate the `{rule.name}` provided above?"
+            f"should I take some measure to fix that violation? true for I do need, false for I don't need.",
             **override_kwargs(kwargs, default=None),
         ):
             logger.info(f"Rule `{rule.name}` violated: \n{judge.display()}")