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

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__ = [

fenix_mcp/domain/productivity.py

@@ -4,7 +4,6 @@
 from __future__ import annotations
 
 import asyncio
-from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Dict, Iterable, List, Optional
 
@@ -94,7 +93,9 @@ class ProductivityService:
     async def stats(self) -> Dict[str, Any]:
         return await self._call(self._api.get_todo_stats) or {}
 
-    async def search(self, query: str, *, limit: int, offset: int) -> List[Dict[str, Any]]:
+    async def search(
+        self, query: str, *, limit: int, offset: int
+    ) -> List[Dict[str, Any]]:
         # API atual não expõe paginação no endpoint de busca, mas mantemos
         # assinatura para possível suporte futuro.
         result = await self._call(self._api.search_todo_items, query=query)

fenix_mcp/domain/user_config.py

@@ -21,13 +21,20 @@ class UserConfigService:
         payload = _strip_none(data)
         return await asyncio.to_thread(self._api.create_user_core_document, payload)
 
-    async def list(self, *, returnContent: Optional[bool] = None, **_: Any) -> List[Dict[str, Any]]:
-        return await asyncio.to_thread(
-            self._api.list_user_core_documents,
-            return_content=bool(returnContent),
-        ) or []
+    async def list(
+        self, *, returnContent: Optional[bool] = None, **_: Any
+    ) -> List[Dict[str, Any]]:
+        return (
+            await asyncio.to_thread(
+                self._api.list_user_core_documents,
+                return_content=bool(returnContent),
+            )
+            or []
+        )
 
-    async def get(self, doc_id: str, *, returnContent: Optional[bool] = None, **_: Any) -> Dict[str, Any]:
+    async def get(
+        self, doc_id: str, *, returnContent: Optional[bool] = None, **_: Any
+    ) -> Dict[str, Any]:
         return await asyncio.to_thread(
             self._api.get_user_core_document,
             doc_id,
@@ -36,7 +43,9 @@ class UserConfigService:
 
     async def update(self, doc_id: str, data: Dict[str, Any]) -> Dict[str, Any]:
         payload = _strip_none(data)
-        return await asyncio.to_thread(self._api.update_user_core_document, doc_id, payload)
+        return await asyncio.to_thread(
+            self._api.update_user_core_document, doc_id, payload
+        )
 
     async def delete(self, doc_id: str) -> None:
         await asyncio.to_thread(self._api.delete_user_core_document, doc_id)

fenix_mcp/infrastructure/config.py

@@ -17,14 +17,18 @@ class Settings(BaseSettings):
         default="https://fenix-api-production-7619.up.railway.app",
         description="Base URL for the Fênix Cloud API.",
     )
-    http_timeout: float = Field(default=30.0, description="Default HTTP timeout in seconds.")
+    http_timeout: float = Field(
+        default=30.0, description="Default HTTP timeout in seconds."
+    )
     log_level: str = Field(default="INFO", description="Root log level.")
     transport_mode: Literal["stdio", "http", "both"] = Field(
         default="stdio",
         description="Active transport mode: stdio, http or both.",
     )
     http_host: str = Field(default="127.0.0.1", description="HTTP bind host.")
-    http_port: int = Field(default=3000, description="HTTP port when running with network transport.")
+    http_port: int = Field(
+        default=3000, description="HTTP port when running with network transport."
+    )
 
     model_config = SettingsConfigDict(
         populate_by_name=True,

fenix_mcp/infrastructure/context.py

@@ -17,4 +17,3 @@ class AppContext:
     settings: Settings
     logger: Logger
     api_client: FenixApiClient
-