fenix-mcp 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

fenix_mcp/application/tools/productivity.py

@@ -4,7 +4,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Any, Dict, Iterable, List, Optional
+from typing import Any, Dict, List, Optional
 
 from pydantic import Field
 
@@ -51,24 +51,36 @@ class TodoAction(str, Enum):
 
 ACTION_FIELD_DESCRIPTION = (
     "Ação de produtividade (TODO). Escolha um dos valores: "
-    + ", ".join(f"`{member.value}` ({member.description.rstrip('.')})." for member in TodoAction)
+    + ", ".join(
+        f"`{member.value}` ({member.description.rstrip('.')})." for member in TodoAction
+    )
 )
 
 
 class ProductivityRequest(ToolRequest):
     action: TodoAction = Field(description=ACTION_FIELD_DESCRIPTION)
     id: Optional[str] = Field(default=None, description="Identificador do item TODO.")
-    title: Optional[str] = Field(default=None, description="Título do TODO (obrigatório em create).")
-    content: Optional[str] = Field(default=None, description="Conteúdo em Markdown (obrigatório em create).")
+    title: Optional[str] = Field(
+        default=None, description="Título do TODO (obrigatório em create)."
+    )
+    content: Optional[str] = Field(
+        default=None, description="Conteúdo em Markdown (obrigatório em create)."
+    )
     status: Optional[str] = Field(default="pending", description="Status do TODO.")
     priority: Optional[str] = Field(default="medium", description="Prioridade do TODO.")
     category: Optional[str] = Field(default=None, description="Categoria opcional.")
     tags: Optional[List[str]] = Field(default=None, description="Lista de tags.")
-    due_date: Optional[str] = Field(default=None, description="Data de vencimento do TODO (ISO).")
-    limit: int = Field(default=20, ge=1, le=100, description="Limite de resultados em list/search.")
+    due_date: Optional[str] = Field(
+        default=None, description="Data de vencimento do TODO (ISO)."
+    )
+    limit: int = Field(
+        default=20, ge=1, le=100, description="Limite de resultados em list/search."
+    )
     offset: int = Field(default=0, ge=0, description="Offset de paginação.")
     query: Optional[str] = Field(default=None, description="Termo de busca.")
-    days: Optional[int] = Field(default=None, ge=1, le=30, description="Janela de dias para upcoming.")
+    days: Optional[int] = Field(
+        default=None, ge=1, le=30, description="Janela de dias para upcoming."
+    )
 
 
 class ProductivityTool(Tool):
@@ -175,7 +187,9 @@ class ProductivityTool(Tool):
     async def _handle_search(self, payload: ProductivityRequest):
         if not payload.query:
             return text("❌ Informe um termo de busca (query).")
-        todos = await self._service.search(payload.query, limit=payload.limit, offset=payload.offset)
+        todos = await self._service.search(
+            payload.query, limit=payload.limit, offset=payload.offset
+        )
         if not todos:
             return text("🔍 Nenhum TODO encontrado para a busca.")
         body = "\n\n".join(ProductivityService.format_todo(todo) for todo in todos)
@@ -213,7 +227,10 @@ class ProductivityTool(Tool):
         return text(f"🔖 **Tags utilizadas:**\n{body}")
 
     async def _handle_help(self):
-        return text("📚 **Ações disponíveis para productivity**\n\n" + TodoAction.formatted_help())
+        return text(
+            "📚 **Ações disponíveis para productivity**\n\n"
+            + TodoAction.formatted_help()
+        )
 
     @staticmethod
     def _format_single(todo: Dict[str, Any], *, header: str) -> str:

fenix_mcp/application/tools/user_config.py

@@ -4,7 +4,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from pydantic import Field
 
@@ -43,9 +43,9 @@ class UserConfigAction(str, Enum):
         return "\n".join(lines)
 
 
-ACTION_FIELD_DESCRIPTION = (
-    "Ação a executar. Escolha um dos valores: "
-    + ", ".join(f"`{member.value}` ({member.description.rstrip('.')})." for member in UserConfigAction)
+ACTION_FIELD_DESCRIPTION = "Ação a executar. Escolha um dos valores: " + ", ".join(
+    f"`{member.value}` ({member.description.rstrip('.')})."
+    for member in UserConfigAction
 )
 
 
@@ -53,12 +53,18 @@ class UserConfigRequest(ToolRequest):
     action: UserConfigAction = Field(description=ACTION_FIELD_DESCRIPTION)
     id: Optional[str] = Field(default=None, description="ID do documento.")
     name: Optional[str] = Field(default=None, description="Nome do documento.")
-    content: Optional[str] = Field(default=None, description="Conteúdo em Markdown/JSON.")
+    content: Optional[str] = Field(
+        default=None, description="Conteúdo em Markdown/JSON."
+    )
     mode_id: Optional[str] = Field(default=None, description="ID do modo associado.")
-    is_default: Optional[bool] = Field(default=None, description="Marca o documento como padrão.")
+    is_default: Optional[bool] = Field(
+        default=None, description="Marca o documento como padrão."
+    )
     limit: int = Field(default=20, ge=1, le=100, description="Limite para listagem.")
     offset: int = Field(default=0, ge=0, description="Offset para listagem.")
-    return_content: Optional[bool] = Field(default=None, description="Retorna conteúdo completo.")
+    return_content: Optional[bool] = Field(
+        default=None, description="Retorna conteúdo completo."
+    )
 
 
 class UserConfigTool(Tool):
@@ -125,7 +131,7 @@ class UserConfigTool(Tool):
 
         if action is UserConfigAction.DELETE:
             if not payload.id:
-                return text("❌ Informe o ID do documento." )
+                return text("❌ Informe o ID do documento.")
             await self._service.delete(payload.id)
             return text(f"🗑️ Documento {payload.id} removido.")
 
@@ -135,7 +141,10 @@ class UserConfigTool(Tool):
         )
 
     async def _handle_help(self):
-        return text("📚 **Ações disponíveis para user_config**\n\n" + UserConfigAction.formatted_help())
+        return text(
+            "📚 **Ações disponíveis para user_config**\n\n"
+            + UserConfigAction.formatted_help()
+        )
 
 
 def _format_doc(doc: Dict[str, Any], header: Optional[str] = None) -> str:

fenix_mcp/domain/initialization.py

@@ -25,7 +25,9 @@ class InitializationService:
         self._api = api_client
         self._logger = logger
 
-    async def gather_data(self, *, include_user_docs: bool, limit: int) -> InitializationData:
+    async def gather_data(
+        self, *, include_user_docs: bool, limit: int
+    ) -> InitializationData:
         profile = await self._safe_call(self._api.get_profile)
         core_docs = await self._safe_call(
             self._api.list_core_documents,
@@ -35,10 +37,13 @@ class InitializationService:
             self._logger.debug("Core docs response", extra={"core_docs": core_docs})
         user_docs: List[Dict[str, Any]] = []
         if include_user_docs:
-            user_docs = await self._safe_call(
-                self._api.list_user_core_documents,
-                return_content=True,
-            ) or []
+            user_docs = (
+                await self._safe_call(
+                    self._api.list_user_core_documents,
+                    return_content=True,
+                )
+                or []
+            )
             if self._logger:
                 self._logger.debug("User docs response", extra={"user_docs": user_docs})
         memories = await self._safe_call(
@@ -80,7 +85,9 @@ class InitializationService:
         return []
 
     @staticmethod
-    def build_existing_user_summary(data: InitializationData, include_user_docs: bool) -> str:
+    def build_existing_user_summary(
+        data: InitializationData, include_user_docs: bool
+    ) -> str:
         profile = data.profile or {}
         user_info = profile.get("user") or {}
         tenant_info = profile.get("tenant") or {}
@@ -109,16 +116,21 @@ class InitializationService:
 
         if core_count:
             preview = ", ".join(
-                doc.get("name", doc.get("title", "sem título")) for doc in data.core_documents[:5]
+                doc.get("name", doc.get("title", "sem título"))
+                for doc in data.core_documents[:5]
             )
             lines.append(f"- Exemplos de documentos principais: {preview}")
 
         if include_user_docs and user_count:
-            preview = ", ".join(doc.get("name", "sem título") for doc in data.user_documents[:5])
+            preview = ", ".join(
+                doc.get("name", "sem título") for doc in data.user_documents[:5]
+            )
             lines.append(f"- Exemplos de documentos pessoais: {preview}")
 
         if memories_count:
-            preview = ", ".join(mem.get("title", "sem título") for mem in data.recent_memories[:3])
+            preview = ", ".join(
+                mem.get("title", "sem título") for mem in data.recent_memories[:3]
+            )
             lines.append(f"- Memórias recentes: {preview}")
 
         lines.append("")

fenix_mcp/domain/intelligence.py

@@ -44,12 +44,15 @@ class IntelligenceService:
         params = _strip_none(filters)
         include_content = bool(params.pop("content", True))
         include_metadata = bool(params.pop("metadata", False))
-        return await self._call(
-            self.api.list_memories,
-            include_content=include_content,
-            include_metadata=include_metadata,
-            **params,
-        ) or []
+        return (
+            await self._call(
+                self.api.list_memories,
+                include_content=include_content,
+                include_metadata=include_metadata,
+                **params,
+            )
+            or []
+        )
 
     async def similar_memories(
         self, *, content: str, threshold: float, max_results: int
@@ -58,7 +61,9 @@ class IntelligenceService:
             "content": content,
             "threshold": threshold,
         }
-        result = await self._call(self.api.find_similar_memories, _strip_none(payload)) or []
+        result = (
+            await self._call(self.api.find_similar_memories, _strip_none(payload)) or []
+        )
         if isinstance(result, list) and max_results:
             return result[:max_results]
         return result
@@ -78,15 +83,20 @@ class IntelligenceService:
             "sortBy": "priority_score",
             "sortOrder": "desc",
         }
-        return await self._call(
-            self.api.list_memories,
-            include_content=False,
-            include_metadata=False,
-            **params,
-        ) or []
+        return (
+            await self._call(
+                self.api.list_memories,
+                include_content=False,
+                include_metadata=False,
+                **params,
+            )
+            or []
+        )
 
     async def analytics(self, *, time_range: str, group_by: str) -> Dict[str, Any]:
-        memories = await self.query_memories(limit=200, timeRange=time_range, groupBy=group_by)
+        memories = await self.query_memories(
+            limit=200, timeRange=time_range, groupBy=group_by
+        )
         summary: Dict[str, Any] = {
             "total_memories": len(memories),
             "by_group": {},
@@ -100,7 +110,9 @@ class IntelligenceService:
     async def update_memory(self, memory_id: str, **fields: Any) -> Dict[str, Any]:
         payload = _strip_none(fields)
         if "importance" in payload:
-            payload["priority_score"] = _importance_to_priority(payload.pop("importance"))
+            payload["priority_score"] = _importance_to_priority(
+                payload.pop("importance")
+            )
         mapping = {
             "documentation_item_id": "documentationItemId",
             "mode_id": "modeId",

fenix_mcp/domain/knowledge.py

@@ -72,8 +72,12 @@ class KnowledgeService:
     async def work_get(self, work_id: str) -> Dict[str, Any]:
         return await self._call_dict(self.api.get_work_item, work_id)
 
-    async def work_update(self, work_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call(self.api.update_work_item, work_id, _strip_none(payload))
+    async def work_update(
+        self, work_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        return await self._call(
+            self.api.update_work_item, work_id, _strip_none(payload)
+        )
 
     async def work_delete(self, work_id: str) -> None:
         await self._call(self.api.delete_work_item, work_id)
@@ -81,7 +85,9 @@ class KnowledgeService:
     async def work_backlog(self, *, team_id: str) -> List[Dict[str, Any]]:
         return await self._call_list(self.api.list_work_items_backlog, team_id=team_id)
 
-    async def work_search(self, *, query: str, team_id: str, limit: int) -> List[Dict[str, Any]]:
+    async def work_search(
+        self, *, query: str, team_id: str, limit: int
+    ) -> List[Dict[str, Any]]:
         return await self._call_list(
             self.api.search_work_items,
             query=query,
@@ -90,29 +96,46 @@ class KnowledgeService:
         )
 
     async def work_analytics(self, *, team_id: str) -> Dict[str, Any]:
-        return await self._call(self.api.get_work_items_analytics, team_id=team_id) or {}
+        return (
+            await self._call(self.api.get_work_items_analytics, team_id=team_id) or {}
+        )
 
-    async def work_velocity(self, *, team_id: str, sprints_count: int) -> Dict[str, Any]:
-        return await self._call(
-            self.api.get_work_items_velocity,
-            team_id=team_id,
-            sprints_count=sprints_count,
-        ) or {}
+    async def work_velocity(
+        self, *, team_id: str, sprints_count: int
+    ) -> Dict[str, Any]:
+        return (
+            await self._call(
+                self.api.get_work_items_velocity,
+                team_id=team_id,
+                sprints_count=sprints_count,
+            )
+            or {}
+        )
 
     async def work_by_sprint(self, *, sprint_id: str) -> List[Dict[str, Any]]:
-        return await self._call_list(self.api.list_work_items_by_sprint, sprint_id=sprint_id)
+        return await self._call_list(
+            self.api.list_work_items_by_sprint, sprint_id=sprint_id
+        )
 
     async def work_burndown(self, *, sprint_id: str) -> Dict[str, Any]:
-        return await self._call(self.api.get_work_items_burndown, sprint_id=sprint_id) or {}
+        return (
+            await self._call(self.api.get_work_items_burndown, sprint_id=sprint_id)
+            or {}
+        )
 
     async def work_by_epic(self, *, epic_id: str) -> List[Dict[str, Any]]:
         return await self._call(self.api.list_work_items_by_epic, epic_id=epic_id) or []
 
     async def work_epic_progress(self, *, epic_id: str) -> Dict[str, Any]:
-        return await self._call(self.api.get_work_items_epic_progress, epic_id=epic_id) or {}
+        return (
+            await self._call(self.api.get_work_items_epic_progress, epic_id=epic_id)
+            or {}
+        )
 
     async def work_by_board(self, *, board_id: str) -> List[Dict[str, Any]]:
-        return await self._call_list(self.api.list_work_items_by_board, board_id=board_id)
+        return await self._call_list(
+            self.api.list_work_items_by_board, board_id=board_id
+        )
 
     async def work_children(self, work_id: str) -> List[Dict[str, Any]]:
         return await self._call_list(self.api.get_work_item_children, work_id)
@@ -120,17 +143,27 @@ class KnowledgeService:
     async def work_move(self, work_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
         return await self._call(self.api.move_work_item, work_id, _strip_none(payload))
 
-    async def work_update_status(self, work_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call(self.api.update_work_item_status, work_id, _strip_none(payload))
+    async def work_update_status(
+        self, work_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        return await self._call(
+            self.api.update_work_item_status, work_id, _strip_none(payload)
+        )
 
-    async def work_move_to_board(self, work_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call(self.api.move_work_item_to_board, work_id, _strip_none(payload))
+    async def work_move_to_board(
+        self, work_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        return await self._call(
+            self.api.move_work_item_to_board, work_id, _strip_none(payload)
+        )
 
     async def work_link(self, work_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
         return await self._call(self.api.link_work_item, work_id, _strip_none(payload))
 
     async def work_assign_to_sprint(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call(self.api.assign_work_items_to_sprint, _strip_none(payload))
+        return await self._call(
+            self.api.assign_work_items_to_sprint, _strip_none(payload)
+        )
 
     async def work_bulk_update(self, payload: Dict[str, Any]) -> Dict[str, Any]:
         return await self._call(self.api.bulk_update_work_items, _strip_none(payload))
@@ -153,7 +186,9 @@ class KnowledgeService:
         result = await self._call(self.api.list_favorite_work_boards)
         return _ensure_list(result)
 
-    async def board_search(self, *, query: str, team_id: str, limit: int) -> List[Dict[str, Any]]:
+    async def board_search(
+        self, *, query: str, team_id: str, limit: int
+    ) -> List[Dict[str, Any]]:
         result = await self._call(
             self.api.search_work_boards,
             query=query,
@@ -170,8 +205,12 @@ class KnowledgeService:
         result = await self._call(self.api.get_work_board, board_id)
         return _ensure_dict(result)
 
-    async def board_update(self, board_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call(self.api.update_work_board, board_id, _strip_none(payload))
+    async def board_update(
+        self, board_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        return await self._call(
+            self.api.update_work_board, board_id, _strip_none(payload)
+        )
 
     async def board_delete(self, board_id: str) -> None:
         await self._call(self.api.delete_work_board, board_id)
@@ -183,11 +222,19 @@ class KnowledgeService:
         result = await self._call(self.api.list_work_board_columns, board_id)
         return _ensure_list(result)
 
-    async def board_toggle_favorite(self, board_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call(self.api.toggle_work_board_favorite, board_id, _strip_none(payload))
+    async def board_toggle_favorite(
+        self, board_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        return await self._call(
+            self.api.toggle_work_board_favorite, board_id, _strip_none(payload)
+        )
 
-    async def board_clone(self, board_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call(self.api.clone_work_board, board_id, _strip_none(payload))
+    async def board_clone(
+        self, board_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        return await self._call(
+            self.api.clone_work_board, board_id, _strip_none(payload)
+        )
 
     async def board_reorder(self, payload: Dict[str, Any]) -> Dict[str, Any]:
         return await self._call(self.api.reorder_work_boards, _strip_none(payload))
@@ -196,13 +243,19 @@ class KnowledgeService:
         return await self._call(self.api.create_work_board_column, _strip_none(payload))
 
     async def board_column_reorder(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call(self.api.reorder_work_board_columns, _strip_none(payload))
+        return await self._call(
+            self.api.reorder_work_board_columns, _strip_none(payload)
+        )
 
     async def board_column_get(self, column_id: str) -> Dict[str, Any]:
         return await self._call(self.api.get_work_board_column, column_id)
 
-    async def board_column_update(self, column_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call(self.api.update_work_board_column, column_id, _strip_none(payload))
+    async def board_column_update(
+        self, column_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        return await self._call(
+            self.api.update_work_board_column, column_id, _strip_none(payload)
+        )
 
     async def board_column_delete(self, column_id: str) -> None:
         await self._call(self.api.delete_work_board_column, column_id)
@@ -219,7 +272,9 @@ class KnowledgeService:
     async def sprint_get(self, sprint_id: str) -> Dict[str, Any]:
         return await self._call_dict(self.api.get_sprint, sprint_id)
 
-    async def sprint_update(self, sprint_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+    async def sprint_update(
+        self, sprint_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
         return await self._call(self.api.update_sprint, sprint_id, _strip_none(payload))
 
     async def sprint_delete(self, sprint_id: str) -> None:
@@ -229,9 +284,14 @@ class KnowledgeService:
         return await self._call_list(self.api.list_sprints_by_team, team_id=team_id)
 
     async def sprint_recent(self, *, team_id: str, limit: int) -> List[Dict[str, Any]]:
-        return await self._call(self.api.list_recent_sprints, team_id=team_id, limit=limit) or []
+        return (
+            await self._call(self.api.list_recent_sprints, team_id=team_id, limit=limit)
+            or []
+        )
 
-    async def sprint_search(self, *, query: str, team_id: str, limit: int) -> List[Dict[str, Any]]:
+    async def sprint_search(
+        self, *, query: str, team_id: str, limit: int
+    ) -> List[Dict[str, Any]]:
         return await self._call_list(
             self.api.search_sprints,
             query=query,
@@ -251,11 +311,17 @@ class KnowledgeService:
     async def sprint_work_items(self, sprint_id: str) -> List[Dict[str, Any]]:
         return await self._call_list(self.api.get_sprint_work_items, sprint_id)
 
-    async def sprint_add_work_items(self, sprint_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call(self.api.add_work_items_to_sprint, sprint_id, _strip_none(payload))
+    async def sprint_add_work_items(
+        self, sprint_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        return await self._call(
+            self.api.add_work_items_to_sprint, sprint_id, _strip_none(payload)
+        )
 
     async def sprint_remove_work_items(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call(self.api.remove_work_items_from_sprint, _strip_none(payload))
+        return await self._call(
+            self.api.remove_work_items_from_sprint, _strip_none(payload)
+        )
 
     async def sprint_analytics(self, sprint_id: str) -> Dict[str, Any]:
         return await self._call(self.api.get_sprint_analytics, sprint_id) or {}
@@ -263,11 +329,17 @@ class KnowledgeService:
     async def sprint_capacity(self, sprint_id: str) -> Dict[str, Any]:
         return await self._call(self.api.get_sprint_capacity, sprint_id) or {}
 
-    async def sprint_start(self, sprint_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+    async def sprint_start(
+        self, sprint_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
         return await self._call(self.api.start_sprint, sprint_id, _strip_none(payload))
 
-    async def sprint_complete(self, sprint_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call(self.api.complete_sprint, sprint_id, _strip_none(payload))
+    async def sprint_complete(
+        self, sprint_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        return await self._call(
+            self.api.complete_sprint, sprint_id, _strip_none(payload)
+        )
 
     async def sprint_cancel(self, sprint_id: str) -> Dict[str, Any]:
         return await self._call(self.api.cancel_sprint, sprint_id)
@@ -285,12 +357,15 @@ class KnowledgeService:
         return_description: Optional[bool] = None,
         return_metadata: Optional[bool] = None,
     ) -> List[Dict[str, Any]]:
-        return await self._call(
-            self.api.list_modes,
-            include_rules=include_rules,
-            return_description=return_description,
-            return_metadata=return_metadata,
-        ) or []
+        return (
+            await self._call(
+                self.api.list_modes,
+                include_rules=include_rules,
+                return_description=return_description,
+                return_metadata=return_metadata,
+            )
+            or []
+        )
 
     async def mode_get(
         self,
@@ -306,7 +381,9 @@ class KnowledgeService:
             return_metadata=return_metadata,
         )
 
-    async def mode_update(self, mode_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+    async def mode_update(
+        self, mode_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
         return await self._call(self.api.update_mode, mode_id, _strip_none(payload))
 
     async def mode_delete(self, mode_id: str) -> None:
@@ -334,12 +411,15 @@ class KnowledgeService:
         return_metadata: Optional[bool] = None,
         return_modes: Optional[bool] = None,
     ) -> List[Dict[str, Any]]:
-        return await self._call(
-            self.api.list_rules,
-            return_description=return_description,
-            return_metadata=return_metadata,
-            return_modes=return_modes,
-        ) or []
+        return (
+            await self._call(
+                self.api.list_rules,
+                return_description=return_description,
+                return_metadata=return_metadata,
+                return_modes=return_modes,
+            )
+            or []
+        )
 
     async def rule_get(
         self,
@@ -357,7 +437,9 @@ class KnowledgeService:
             return_modes=return_modes,
         )
 
-    async def rule_update(self, rule_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+    async def rule_update(
+        self, rule_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
         return await self._call(self.api.update_rule, rule_id, _strip_none(payload))
 
     async def rule_delete(self, rule_id: str) -> None:
@@ -367,23 +449,33 @@ class KnowledgeService:
     # Documentation
     # ------------------------------------------------------------------
     async def doc_create(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call_dict(self.api.create_documentation_item, _strip_none(payload))
+        return await self._call_dict(
+            self.api.create_documentation_item, _strip_none(payload)
+        )
 
     async def doc_list(self, **filters: Any) -> List[Dict[str, Any]]:
-        result = await self._call(self.api.list_documentation_items, **_strip_none(filters))
+        result = await self._call(
+            self.api.list_documentation_items, **_strip_none(filters)
+        )
         return _ensure_list(result)
 
     async def doc_get(self, doc_id: str, **filters: Any) -> Dict[str, Any]:
-        result = await self._call(self.api.get_documentation_item, doc_id, **_strip_none(filters))
+        result = await self._call(
+            self.api.get_documentation_item, doc_id, **_strip_none(filters)
+        )
         return _ensure_dict(result)
 
     async def doc_update(self, doc_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call_dict(self.api.update_documentation_item, doc_id, _strip_none(payload))
+        return await self._call_dict(
+            self.api.update_documentation_item, doc_id, _strip_none(payload)
+        )
 
     async def doc_delete(self, doc_id: str) -> None:
         await self._call(self.api.delete_documentation_item, doc_id)
 
-    async def doc_search(self, *, query: str, team_id: str, limit: int) -> List[Dict[str, Any]]:
+    async def doc_search(
+        self, *, query: str, team_id: str, limit: int
+    ) -> List[Dict[str, Any]]:
         result = await self._call(
             self.api.search_documentation_items,
             query=query,
@@ -418,16 +510,24 @@ class KnowledgeService:
         return await self._call(self.api.get_documentation_full_tree) or {}
 
     async def doc_move(self, doc_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call_dict(self.api.move_documentation_item, doc_id, _strip_none(payload))
+        return await self._call_dict(
+            self.api.move_documentation_item, doc_id, _strip_none(payload)
+        )
 
     async def doc_publish(self, doc_id: str) -> Dict[str, Any]:
         return await self._call_dict(self.api.publish_documentation_item, doc_id)
 
     async def doc_version(self, doc_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call_dict(self.api.create_documentation_version, doc_id, _strip_none(payload))
+        return await self._call_dict(
+            self.api.create_documentation_version, doc_id, _strip_none(payload)
+        )
 
-    async def doc_duplicate(self, doc_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._call_dict(self.api.duplicate_documentation_item, doc_id, _strip_none(payload))
+    async def doc_duplicate(
+        self, doc_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        return await self._call_dict(
+            self.api.duplicate_documentation_item, doc_id, _strip_none(payload)
+        )
 
 
 __all__ = [