fenix-mcp 1.12.0__tar.gz → 1.14.0__tar.gz

{fenix_mcp-1.12.0 → fenix_mcp-1.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fenix-mcp
-Version: 1.12.0
+Version: 1.14.0
 Summary: Fênix Cloud MCP server implemented in Python
 Author: Fenix Inc
 Requires-Python: >=3.10

{fenix_mcp-1.12.0 → fenix_mcp-1.14.0}/fenix_mcp/__init__.py

@@ -8,4 +8,4 @@ Fênix Cloud MCP Server (Python edition).
 __all__ = ["__version__"]
 
 
-__version__ = "1.12.0"
+__version__ = "1.14.0"

{fenix_mcp-1.12.0 → fenix_mcp-1.14.0}/fenix_mcp/application/tools/knowledge.py

@@ -105,25 +105,39 @@ class KnowledgeAction(str, Enum):
         "Lists work items linked to a sprint.",
     )
 
-    # Modes
-    MODE_CREATE = ("mode_create", "Creates a mode with content and optional metadata.")
-    MODE_LIST = ("mode_list", "Lists registered modes.")
-    MODE_GET = ("mode_get", "Gets full details of a mode.")
-    MODE_UPDATE = ("mode_update", "Updates properties of an existing mode.")
-    MODE_DELETE = ("mode_delete", "Removes a mode.")
-    MODE_RULE_ADD = ("mode_rule_add", "Associates a rule with a mode.")
-    MODE_RULE_REMOVE = (
-        "mode_rule_remove",
-        "Removes the association of a rule with a mode.",
-    )
-    MODE_RULES = ("mode_rules", "Lists rules associated with a mode.")
-
     # Rules
-    RULE_CREATE = ("rule_create", "Creates a rule with content and metadata.")
-    RULE_LIST = ("rule_list", "Lists registered rules.")
-    RULE_GET = ("rule_get", "Gets rule details.")
-    RULE_UPDATE = ("rule_update", "Updates an existing rule.")
-    RULE_DELETE = ("rule_delete", "Removes a rule.")
+    RULE_CREATE = (
+        "rule_create",
+        "Creates a new rule. REQUIRED: rule_scope (personal|team|organization|marketplace), rule_name, rule_content. Optional: rule_description, rule_slug. If scope=team, rule_team_id is also required.",
+    )
+    RULE_LIST = (
+        "rule_list",
+        "Lists rules accessible to the current user. Optional filters: rule_scope, query, limit, offset.",
+    )
+    RULE_GET = (
+        "rule_get",
+        "Gets full details of a rule. REQUIRED: rule_id (or id).",
+    )
+    RULE_UPDATE = (
+        "rule_update",
+        "Updates an existing rule. REQUIRED: rule_id (or id). Optional: rule_name, rule_description, rule_content, rule_is_active.",
+    )
+    RULE_DELETE = (
+        "rule_delete",
+        "Deletes a rule. REQUIRED: rule_id (or id).",
+    )
+    RULE_MARKETPLACE = (
+        "rule_marketplace",
+        "Lists public marketplace rules. Optional filters: query, limit, offset.",
+    )
+    RULE_FORK = (
+        "rule_fork",
+        "Forks a rule to a new scope. REQUIRED: rule_id (or id), rule_scope (personal|team|organization). Optional: rule_name, rule_team_id (required if scope=team).",
+    )
+    RULE_EXPORT = (
+        "rule_export",
+        "Exports a rule to a specific format. REQUIRED: rule_id (or id), rule_export_format (cursor|claude|copilot|windsurf).",
+    )
 
     # Documentation - Navigation workflow: doc_full_tree -> doc_children -> doc_get
     DOC_CREATE = (
@@ -283,40 +297,6 @@ class KnowledgeRequest(ToolRequest):
         ),
     )
 
-    # Mode fields
-    mode_id: Optional[UUIDStr] = Field(
-        default=None, description="Related mode ID (UUID)."
-    )
-    mode_name: Optional[TitleStr] = Field(default=None, description="Mode name.")
-    mode_description: Optional[DescriptionStr] = Field(
-        default=None, description="Mode description."
-    )
-    mode_content: Optional[MarkdownStr] = Field(
-        default=None, description="Mode content (Markdown)."
-    )
-    mode_is_default: Optional[bool] = Field(
-        default=None, description="Indicates if the mode is default."
-    )
-    mode_metadata: Optional[MarkdownStr] = Field(
-        default=None, description="Mode metadata for AI processing."
-    )
-
-    # Rule fields
-    rule_id: Optional[UUIDStr] = Field(
-        default=None, description="Related rule ID (UUID)."
-    )
-    rule_name: Optional[TitleStr] = Field(default=None, description="Rule name.")
-    rule_description: Optional[DescriptionStr] = Field(
-        default=None, description="Rule description."
-    )
-    rule_content: Optional[MarkdownStr] = Field(
-        default=None, description="Rule content (Markdown)."
-    )
-    rule_is_default: Optional[bool] = Field(default=None, description="Default rule.")
-    rule_metadata: Optional[MarkdownStr] = Field(
-        default=None, description="Rule metadata for AI processing."
-    )
-
     # Documentation fields
     doc_title: Optional[TitleStr] = Field(
         default=None, description="Documentation title."
@@ -369,10 +349,39 @@ class KnowledgeRequest(ToolRequest):
         default=None, description="Whether the document is public."
     )
 
+    # Rule fields
+    rule_id: Optional[UUIDStr] = Field(default=None, description="Rule ID (UUID).")
+    rule_scope: Optional[str] = Field(
+        default=None,
+        description="Rule scope. Values: personal, team, organization, marketplace.",
+    )
+    rule_name: Optional[TitleStr] = Field(default=None, description="Rule name.")
+    rule_slug: Optional[str] = Field(
+        default=None, description="Rule slug (auto-generated if not provided)."
+    )
+    rule_description: Optional[DescriptionStr] = Field(
+        default=None, description="Rule description."
+    )
+    rule_content: Optional[MarkdownStr] = Field(
+        default=None, description=f"Rule content (Markdown).{MERMAID_HINT}"
+    )
+    rule_team_id: Optional[UUIDStr] = Field(
+        default=None, description="Team ID for team-scoped rules (UUID)."
+    )
+    rule_export_format: Optional[str] = Field(
+        default=None,
+        description="Export format. Values: cursor, claude, copilot, windsurf.",
+    )
+    rule_is_active: Optional[bool] = Field(
+        default=None, description="Whether the rule is active."
+    )
+
 
 class KnowledgeTool(Tool):
     name = "knowledge"
-    description = "Fenix Cloud knowledge operations (Work Items, Boards, Sprints, Modes, Rules, Docs)."
+    description = (
+        "Fenix Cloud knowledge operations (Work Items, Boards, Sprints, Rules, Docs)."
+    )
     request_model = KnowledgeRequest
 
     def __init__(self, context: AppContext):
@@ -389,8 +398,6 @@ class KnowledgeTool(Tool):
             return await self._run_board(payload)
         if action.value.startswith("sprint_"):
             return await self._run_sprint(payload)
-        if action.value.startswith("mode_"):
-            return await self._run_mode(payload)
         if action.value.startswith("rule_"):
             return await self._run_rule(payload)
         if action.value.startswith("doc_"):
@@ -820,195 +827,123 @@ class KnowledgeTool(Tool):
             )
         )
 
-    # ------------------------------------------------------------------
-    # Modes
-    # ------------------------------------------------------------------
-    async def _run_mode(self, payload: KnowledgeRequest):
-        action = payload.action
-        if action is KnowledgeAction.MODE_CREATE:
-            if not payload.mode_name:
-                return text("❌ Provide mode_name to create the mode.")
-            mode = await self._service.mode_create(
-                {
-                    "name": payload.mode_name,
-                    "description": payload.mode_description,
-                    "content": payload.mode_content,
-                    "is_default": payload.mode_is_default,
-                    "metadata": payload.mode_metadata,
-                }
-            )
-            return text(_format_mode(mode, header="✅ Mode created"))
-
-        if action is KnowledgeAction.MODE_LIST:
-            modes = await self._service.mode_list(
-                include_rules=payload.return_metadata,
-                return_description=payload.return_description,
-                return_metadata=payload.return_metadata,
-            )
-            if not modes:
-                return text("🎭 No modes found.")
-            body = "\n\n".join(_format_mode(mode) for mode in modes)
-            return text(f"🎭 **Modes ({len(modes)}):**\n\n{body}")
-
-        if action is KnowledgeAction.MODE_GET:
-            if not payload.mode_id:
-                return text("❌ Provide mode_id to get details.")
-            mode = await self._service.mode_get(
-                payload.mode_id,
-                return_description=payload.return_description,
-                return_metadata=payload.return_metadata,
-            )
-            # Buscar rules associadas ao mode
-            associations = await self._service.mode_rules(payload.mode_id)
-            rules = [assoc.get("rule", assoc) for assoc in associations]
-
-            # Formatar resposta com rules (incluindo content)
-            output = _format_mode(mode, header="🎭 Mode details", show_content=True)
-            if rules:
-                rules_parts = []
-                for r in rules:
-                    rule_text = f"### 📋 {r.get('name', 'Unnamed')}\n"
-                    rule_text += f"ID: {r.get('id')}\n"
-                    if r.get("content"):
-                        rule_text += f"\n{r.get('content')}"
-                    rules_parts.append(rule_text)
-                output += f"\n\n**Rules ({len(rules)}):**\n\n" + "\n\n---\n\n".join(
-                    rules_parts
-                )
-            return text(output)
-
-        if action is KnowledgeAction.MODE_UPDATE:
-            if not payload.mode_id:
-                return text("❌ Provide mode_id to update.")
-            mode = await self._service.mode_update(
-                payload.mode_id,
-                {
-                    "name": payload.mode_name,
-                    "description": payload.mode_description,
-                    "content": payload.mode_content,
-                    "is_default": payload.mode_is_default,
-                    "metadata": payload.mode_metadata,
-                },
-            )
-            return text(_format_mode(mode, header="✅ Mode updated"))
-
-        if action is KnowledgeAction.MODE_DELETE:
-            if not payload.mode_id:
-                return text("❌ Provide mode_id to remove.")
-            await self._service.mode_delete(payload.mode_id)
-            return text(f"🗑️ Mode {payload.mode_id} removed.")
-
-        if action is KnowledgeAction.MODE_RULE_ADD:
-            if not payload.mode_id or not payload.rule_id:
-                return text("❌ Provide mode_id and rule_id to associate.")
-            link = await self._service.mode_rule_add(payload.mode_id, payload.rule_id)
-            return text(
-                "\n".join(
-                    [
-                        "🔗 **Rule associated with mode!**",
-                        f"Mode: {link.get('modeId', payload.mode_id)}",
-                        f"Rule: {link.get('ruleId', payload.rule_id)}",
-                    ]
-                )
-            )
-
-        if action is KnowledgeAction.MODE_RULE_REMOVE:
-            if not payload.mode_id or not payload.rule_id:
-                return text("❌ Provide mode_id and rule_id to remove the association.")
-            await self._service.mode_rule_remove(payload.mode_id, payload.rule_id)
-            return text("🔗 Association removed.")
-
-        if action is KnowledgeAction.MODE_RULES:
-            if payload.mode_id:
-                associations = await self._service.mode_rules(payload.mode_id)
-                context_label = f"mode {payload.mode_id}"
-                # API retorna [{id, mode_id, rule_id, rule: {...}}] - extrair rule
-                items = [assoc.get("rule", assoc) for assoc in associations]
-            elif payload.rule_id:
-                associations = await self._service.mode_rules_for_rule(payload.rule_id)
-                context_label = f"rule {payload.rule_id}"
-                # API retorna [{id, mode_id, rule_id, mode: {...}}] - extrair mode
-                items = [assoc.get("mode", assoc) for assoc in associations]
-            else:
-                return text("❌ Provide mode_id or rule_id to list associations.")
-            if not items:
-                return text("🔗 No associations found.")
-            body = "\n".join(
-                f"- {item.get('name', 'Unnamed')} (ID: {item.get('id')})"
-                for item in items
-            )
-            return text(f"🔗 **Associations for {context_label}:**\n{body}")
-
-        return text(
-            "❌ Unsupported mode action.\n\nChoose one of the values:\n"
-            + "\n".join(
-                f"- `{value}`"
-                for value in KnowledgeAction.choices()
-                if value.startswith("mode_")
-            )
-        )
-
     # ------------------------------------------------------------------
     # Rules
     # ------------------------------------------------------------------
     async def _run_rule(self, payload: KnowledgeRequest):
         action = payload.action
+
         if action is KnowledgeAction.RULE_CREATE:
-            if not payload.rule_name or not payload.rule_content:
-                return text("❌ Provide rule_name and rule_content.")
+            if not payload.rule_name:
+                return text("❌ Provide rule_name to create the rule.")
+            if not payload.rule_content:
+                return text("❌ Provide rule_content to create the rule.")
+            if not payload.rule_scope:
+                return text(
+                    "❌ Provide rule_scope to create the rule. "
+                    "Values: personal, team, organization, marketplace."
+                )
+            if payload.rule_scope == "team" and not payload.rule_team_id:
+                return text("❌ Provide rule_team_id for team-scoped rules.")
+
             rule = await self._service.rule_create(
                 {
+                    "scope": payload.rule_scope,
                     "name": payload.rule_name,
-                    "description": payload.rule_description,
+                    "slug": sanitize_null(payload.rule_slug),
+                    "description": sanitize_null(payload.rule_description),
                     "content": payload.rule_content,
-                    "is_default": payload.rule_is_default,
-                    "metadata": payload.rule_metadata,
+                    "team_id": sanitize_null(payload.rule_team_id),
                 }
             )
             return text(_format_rule(rule, header="✅ Rule created"))
 
         if action is KnowledgeAction.RULE_LIST:
             rules = await self._service.rule_list(
-                return_description=payload.return_description,
-                return_metadata=payload.return_metadata,
-                return_modes=payload.return_metadata,
+                limit=payload.limit,
+                offset=payload.offset,
+                scope=sanitize_null(payload.rule_scope),
+                query=sanitize_null(payload.query),
             )
             if not rules:
-                return text("📋 No rules found.")
+                return text("📜 No rules found.")
             body = "\n\n".join(_format_rule(rule) for rule in rules)
-            return text(f"📋 **Rules ({len(rules)}):**\n\n{body}")
+            return text(f"📜 **Rules ({len(rules)}):**\n\n{body}")
 
         if action is KnowledgeAction.RULE_GET:
-            if not payload.rule_id:
-                return text("❌ Provide rule_id to get details.")
-            rule = await self._service.rule_get(
-                payload.rule_id,
-                return_description=payload.return_description,
-                return_metadata=payload.return_metadata,
-                return_modes=payload.return_metadata,
-            )
-            return text(_format_rule(rule, header="📋 Rule details", show_content=True))
+            rule_id = payload.rule_id or payload.id
+            if not rule_id:
+                return text("❌ Provide rule_id or id to get the rule.")
+            rule = await self._service.rule_get(rule_id)
+            return text(_format_rule(rule, header="📜 Rule details", show_content=True))
 
         if action is KnowledgeAction.RULE_UPDATE:
-            if not payload.rule_id:
-                return text("❌ Provide rule_id to update.")
+            rule_id = payload.rule_id or payload.id
+            if not rule_id:
+                return text("❌ Provide rule_id or id to update the rule.")
             rule = await self._service.rule_update(
-                payload.rule_id,
+                rule_id,
                 {
-                    "name": payload.rule_name,
-                    "description": payload.rule_description,
-                    "content": payload.rule_content,
-                    "is_default": payload.rule_is_default,
-                    "metadata": payload.rule_metadata,
+                    "name": sanitize_null(payload.rule_name),
+                    "description": sanitize_null(payload.rule_description),
+                    "content": sanitize_null(payload.rule_content),
+                    "is_active": payload.rule_is_active,
                 },
             )
             return text(_format_rule(rule, header="✅ Rule updated"))
 
         if action is KnowledgeAction.RULE_DELETE:
-            if not payload.rule_id:
-                return text("❌ Provide rule_id to remove.")
-            await self._service.rule_delete(payload.rule_id)
-            return text(f"🗑️ Rule {payload.rule_id} removed.")
+            rule_id = payload.rule_id or payload.id
+            if not rule_id:
+                return text("❌ Provide rule_id or id to delete the rule.")
+            await self._service.rule_delete(rule_id)
+            return text(f"🗑️ Rule {rule_id} removed.")
+
+        if action is KnowledgeAction.RULE_MARKETPLACE:
+            rules = await self._service.rule_marketplace(
+                limit=payload.limit,
+                offset=payload.offset,
+                query=sanitize_null(payload.query),
+            )
+            if not rules:
+                return text("🏪 No marketplace rules found.")
+            body = "\n\n".join(_format_marketplace_rule(rule) for rule in rules)
+            return text(f"🏪 **Marketplace Rules ({len(rules)}):**\n\n{body}")
+
+        if action is KnowledgeAction.RULE_FORK:
+            rule_id = payload.rule_id or payload.id
+            if not rule_id:
+                return text("❌ Provide rule_id or id to fork the rule.")
+            if not payload.rule_scope:
+                return text(
+                    "❌ Provide rule_scope for the forked rule. "
+                    "Values: personal, team, organization."
+                )
+            rule = await self._service.rule_fork(
+                rule_id,
+                {
+                    "scope": payload.rule_scope,
+                    "name": sanitize_null(payload.rule_name),
+                    "team_id": sanitize_null(payload.rule_team_id),
+                },
+            )
+            return text(_format_rule(rule, header="✅ Rule forked"))
+
+        if action is KnowledgeAction.RULE_EXPORT:
+            rule_id = payload.rule_id or payload.id
+            if not rule_id:
+                return text("❌ Provide rule_id or id to export the rule.")
+            if not payload.rule_export_format:
+                return text(
+                    "❌ Provide rule_export_format. "
+                    "Values: cursor, claude, copilot, windsurf."
+                )
+            content = await self._service.rule_export(
+                rule_id, payload.rule_export_format
+            )
+            return text(
+                f"📤 **Export ({payload.rule_export_format}):**\n\n```\n{content}\n```"
+            )
 
         return text(
             "❌ Unsupported rule action.\n\nChoose one of the values:\n"
@@ -1361,8 +1296,8 @@ def _format_sprint(sprint: Dict[str, Any], header: Optional[str] = None) -> str:
     return "\n".join(lines)
 
 
-def _format_mode(
-    mode: Dict[str, Any],
+def _format_doc(
+    doc: Dict[str, Any],
     *,
     header: Optional[str] = None,
     show_content: bool = False,
@@ -1373,17 +1308,23 @@ def _format_mode(
         lines.append("")
     lines.extend(
         [
-            f"🎭 **{mode.get('name', 'Unnamed')}**",
-            f"ID: {mode.get('id', 'N/A')}",
-            f"Default: {mode.get('is_default', False)}",
+            f"📄 **{doc.get('title') or doc.get('name', 'Untitled')}**",
+            f"ID: {doc.get('id', 'N/A')}",
+            f"Status: {doc.get('status', 'N/A')}",
+            f"Team: {doc.get('team_id', 'N/A')}",
         ]
     )
-    if mode.get("description"):
-        lines.append(f"Description: {mode['description']}")
-    if show_content and mode.get("content"):
+    if doc.get("updated_at") or doc.get("updatedAt"):
+        lines.append(
+            f"Updated at: {_format_date(doc.get('updated_at') or doc.get('updatedAt'))}"
+        )
+
+    # Show content only when explicitly requested (e.g., doc_get)
+    if show_content and doc.get("content"):
         lines.append("")
         lines.append("**Content:**")
-        lines.append(mode.get("content"))
+        lines.append(doc.get("content"))
+
     return "\n".join(lines)
 
 
@@ -1397,50 +1338,87 @@ def _format_rule(
     if header:
         lines.append(header)
         lines.append("")
+
+    name = rule.get("name", "Untitled")
+    scope = rule.get("scope", "unknown")
+    scope_emoji = {
+        "personal": "👤",
+        "team": "👥",
+        "organization": "🏢",
+        "marketplace": "🌍",
+    }.get(scope, "📜")
+
     lines.extend(
         [
-            f"📋 **{rule.get('name', 'Unnamed')}**",
+            f"{scope_emoji} **{name}**",
             f"ID: {rule.get('id', 'N/A')}",
-            f"Default: {rule.get('is_default', False)}",
+            f"Scope: {scope}",
+            f"Version: {rule.get('version', '1.0')}",
         ]
     )
+
     if rule.get("description"):
-        lines.append(f"Description: {rule['description']}")
+        lines.append(f"Description: {rule.get('description')}")
+
+    # Author info
+    author = rule.get("author")
+    if isinstance(author, dict):
+        lines.append(f"Author: {author.get('name', 'Unknown')}")
+
+    # Forked from info
+    forked_from = rule.get("forked_from")
+    if isinstance(forked_from, dict):
+        forked_author = forked_from.get("author", {})
+        author_name = (
+            forked_author.get("name", "Unknown")
+            if isinstance(forked_author, dict)
+            else "Unknown"
+        )
+        lines.append(
+            f"Forked from: {forked_from.get('name', 'Unknown')} by {author_name}"
+        )
+
+    if rule.get("is_active") is False:
+        lines.append("Status: Inactive")
+
+    if rule.get("updated_at") or rule.get("updatedAt"):
+        lines.append(
+            f"Updated: {_format_date(rule.get('updated_at') or rule.get('updatedAt'))}"
+        )
+
+    # Show content only when explicitly requested
     if show_content and rule.get("content"):
         lines.append("")
         lines.append("**Content:**")
         lines.append(rule.get("content"))
+
     return "\n".join(lines)
 
 
-def _format_doc(
-    doc: Dict[str, Any],
-    *,
-    header: Optional[str] = None,
-    show_content: bool = False,
-) -> str:
+def _format_marketplace_rule(rule: Dict[str, Any]) -> str:
+    """Format a marketplace rule with download/rating info."""
     lines: List[str] = []
-    if header:
-        lines.append(header)
-        lines.append("")
-    lines.extend(
-        [
-            f"📄 **{doc.get('title') or doc.get('name', 'Untitled')}**",
-            f"ID: {doc.get('id', 'N/A')}",
-            f"Status: {doc.get('status', 'N/A')}",
-            f"Team: {doc.get('team_id', 'N/A')}",
-        ]
-    )
-    if doc.get("updated_at") or doc.get("updatedAt"):
-        lines.append(
-            f"Updated at: {_format_date(doc.get('updated_at') or doc.get('updatedAt'))}"
-        )
 
-    # Show content only when explicitly requested (e.g., doc_get)
-    if show_content and doc.get("content"):
-        lines.append("")
-        lines.append("**Content:**")
-        lines.append(doc.get("content"))
+    name = rule.get("name", "Untitled")
+    downloads = rule.get("downloads", 0)
+    rating = rule.get("rating")
+
+    lines.append(f"🌍 **{name}**")
+    lines.append(f"ID: {rule.get('id', 'N/A')}")
+
+    if rule.get("description"):
+        lines.append(f"Description: {rule.get('description')}")
+
+    # Author info
+    author = rule.get("author")
+    if isinstance(author, dict):
+        lines.append(f"Author: {author.get('name', 'Unknown')}")
+
+    # Stats
+    stats_parts = [f"⬇️ {downloads}"]
+    if rating is not None:
+        stats_parts.append(f"⭐ {float(rating):.1f}")
+    lines.append(" | ".join(stats_parts))
 
     return "\n".join(lines)
 

{fenix_mcp-1.12.0 → fenix_mcp-1.14.0}/fenix_mcp/domain/knowledge.py

@@ -360,123 +360,6 @@ class KnowledgeService:
     async def sprint_cancel(self, sprint_id: str) -> Dict[str, Any]:
         return await self._call(self.api.cancel_sprint, sprint_id)
 
-    # ------------------------------------------------------------------
-    # Modes and rules
-    # ------------------------------------------------------------------
-    async def mode_create(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        result = await self._call(self.api.create_mode, _strip_none(payload))
-        # API returns { message, mode } - extract mode
-        if isinstance(result, dict) and "mode" in result:
-            return result["mode"]
-        return result or {}
-
-    async def mode_list(
-        self,
-        *,
-        include_rules: Optional[bool] = None,
-        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 []
-        )
-
-    async def mode_get(
-        self,
-        mode_id: str,
-        *,
-        return_description: Optional[bool] = None,
-        return_metadata: Optional[bool] = None,
-    ) -> Dict[str, Any]:
-        return await self._call(
-            self.api.get_mode,
-            mode_id,
-            return_description=return_description,
-            return_metadata=return_metadata,
-        )
-
-    async def mode_update(
-        self, mode_id: str, payload: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        result = await self._call(self.api.update_mode, mode_id, _strip_none(payload))
-        # API returns { message, mode } - extract mode
-        if isinstance(result, dict) and "mode" in result:
-            return result["mode"]
-        return result or {}
-
-    async def mode_delete(self, mode_id: str) -> None:
-        await self._call(self.api.delete_mode, mode_id)
-
-    async def mode_rule_add(self, mode_id: str, rule_id: str) -> Dict[str, Any]:
-        return await self._call(self.api.add_mode_rule, mode_id, rule_id)
-
-    async def mode_rule_remove(self, mode_id: str, rule_id: str) -> None:
-        await self._call(self.api.remove_mode_rule, mode_id, rule_id)
-
-    async def mode_rules(self, mode_id: str) -> List[Dict[str, Any]]:
-        return await self._call(self.api.list_rules_by_mode, mode_id) or []
-
-    async def mode_rules_for_rule(self, rule_id: str) -> List[Dict[str, Any]]:
-        return await self._call(self.api.list_modes_by_rule, rule_id) or []
-
-    async def rule_create(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        result = await self._call(self.api.create_rule, _strip_none(payload))
-        # API returns { message, rule } - extract rule
-        if isinstance(result, dict) and "rule" in result:
-            return result["rule"]
-        return result or {}
-
-    async def rule_list(
-        self,
-        *,
-        return_description: Optional[bool] = None,
-        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 []
-        )
-
-    async def rule_get(
-        self,
-        rule_id: str,
-        *,
-        return_description: Optional[bool] = None,
-        return_metadata: Optional[bool] = None,
-        return_modes: Optional[bool] = None,
-    ) -> Dict[str, Any]:
-        return await self._call(
-            self.api.get_rule,
-            rule_id,
-            return_description=return_description,
-            return_metadata=return_metadata,
-            return_modes=return_modes,
-        )
-
-    async def rule_update(
-        self, rule_id: str, payload: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        result = await self._call(self.api.update_rule, rule_id, _strip_none(payload))
-        # API returns { message, rule } - extract rule
-        if isinstance(result, dict) and "rule" in result:
-            return result["rule"]
-        return result or {}
-
-    async def rule_delete(self, rule_id: str) -> None:
-        await self._call(self.api.delete_rule, rule_id)
-
     # ------------------------------------------------------------------
     # Documentation
     # ------------------------------------------------------------------
@@ -549,6 +432,40 @@ class KnowledgeService:
             self.api.duplicate_documentation_item, doc_id, _strip_none(payload)
         )
 
+    # ------------------------------------------------------------------
+    # Rules
+    # ------------------------------------------------------------------
+    async def rule_create(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        return await self._call_dict(self.api.create_rule, _strip_none(payload))
+
+    async def rule_list(self, **filters: Any) -> List[Dict[str, Any]]:
+        return await self._call_list(self.api.list_rules, **_strip_none(filters))
+
+    async def rule_get(self, rule_id: str) -> Dict[str, Any]:
+        return await self._call_dict(self.api.get_rule, rule_id)
+
+    async def rule_update(
+        self, rule_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        return await self._call_dict(
+            self.api.update_rule, rule_id, _strip_none(payload)
+        )
+
+    async def rule_delete(self, rule_id: str) -> None:
+        await self._call(self.api.delete_rule, rule_id)
+
+    async def rule_marketplace(self, **filters: Any) -> List[Dict[str, Any]]:
+        return await self._call_list(
+            self.api.list_marketplace_rules, **_strip_none(filters)
+        )
+
+    async def rule_fork(self, rule_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        return await self._call_dict(self.api.fork_rule, rule_id, _strip_none(payload))
+
+    async def rule_export(self, rule_id: str, format: str) -> str:
+        result = await self._call(self.api.export_rule, rule_id, format)
+        return result if isinstance(result, str) else str(result or "")
+
 
 __all__ = [
     "KnowledgeService",

{fenix_mcp-1.12.0 → fenix_mcp-1.14.0}/fenix_mcp/infrastructure/fenix_api/client.py

@@ -284,105 +284,6 @@ class FenixApiClient:
             "POST", "/api/memory-intelligence/smart-create", json=payload
         )
 
-    # ------------------------------------------------------------------
-    # Configuration: modes and rules
-    # ------------------------------------------------------------------
-
-    def list_modes(
-        self,
-        *,
-        include_rules: Optional[bool] = None,
-        return_description: Optional[bool] = None,
-        return_metadata: Optional[bool] = None,
-    ) -> Any:
-        params = self._build_params(
-            optional={
-                "includeRules": include_rules,
-                "returnDescription": return_description,
-                "returnMetadata": return_metadata,
-            }
-        )
-        return self._request("GET", "/api/modes", params=params)
-
-    def get_mode(
-        self,
-        mode_id: str,
-        *,
-        return_description: Optional[bool] = None,
-        return_metadata: Optional[bool] = None,
-    ) -> Any:
-        params = self._build_params(
-            optional={
-                "returnDescription": return_description,
-                "returnMetadata": return_metadata,
-            }
-        )
-        return self._request("GET", f"/api/modes/{mode_id}", params=params)
-
-    def create_mode(self, payload: Mapping[str, Any]) -> Any:
-        return self._request("POST", "/api/modes", json=payload)
-
-    def update_mode(self, mode_id: str, payload: Mapping[str, Any]) -> Any:
-        return self._request("PATCH", f"/api/modes/{mode_id}", json=payload)
-
-    def delete_mode(self, mode_id: str) -> Any:
-        return self._request("DELETE", f"/api/modes/{mode_id}")
-
-    def list_rules(
-        self,
-        *,
-        return_description: Optional[bool] = None,
-        return_metadata: Optional[bool] = None,
-        return_modes: Optional[bool] = None,
-    ) -> Any:
-        params = self._build_params(
-            optional={
-                "returnDescription": return_description,
-                "returnMetadata": return_metadata,
-                "returnModes": return_modes,
-            }
-        )
-        return self._request("GET", "/api/rules", params=params)
-
-    def get_rule(
-        self,
-        rule_id: str,
-        *,
-        return_description: Optional[bool] = None,
-        return_metadata: Optional[bool] = None,
-        return_modes: Optional[bool] = None,
-    ) -> Any:
-        params = self._build_params(
-            optional={
-                "returnDescription": return_description,
-                "returnMetadata": return_metadata,
-                "returnModes": return_modes,
-            }
-        )
-        return self._request("GET", f"/api/rules/{rule_id}", params=params)
-
-    def create_rule(self, payload: Mapping[str, Any]) -> Any:
-        return self._request("POST", "/api/rules", json=payload)
-
-    def update_rule(self, rule_id: str, payload: Mapping[str, Any]) -> Any:
-        return self._request("PATCH", f"/api/rules/{rule_id}", json=payload)
-
-    def delete_rule(self, rule_id: str) -> Any:
-        return self._request("DELETE", f"/api/rules/{rule_id}")
-
-    def add_mode_rule(self, mode_id: str, rule_id: str) -> Any:
-        payload = {"modeId": mode_id, "ruleId": rule_id}
-        return self._request("POST", "/api/mode-rules", json=payload)
-
-    def remove_mode_rule(self, mode_id: str, rule_id: str) -> Any:
-        return self._request("DELETE", f"/api/mode-rules/mode/{mode_id}/rule/{rule_id}")
-
-    def list_rules_by_mode(self, mode_id: str) -> Any:
-        return self._request("GET", f"/api/mode-rules/mode/{mode_id}/rules")
-
-    def list_modes_by_rule(self, rule_id: str) -> Any:
-        return self._request("GET", f"/api/mode-rules/rule/{rule_id}/modes")
-
     # ------------------------------------------------------------------
     # Knowledge: documentation
     # ------------------------------------------------------------------
@@ -691,3 +592,53 @@ class FenixApiClient:
 
     def cancel_sprint(self, sprint_id: str) -> Any:
         return self._request("PATCH", f"/api/sprints/{sprint_id}/cancel")
+
+    # ------------------------------------------------------------------
+    # Rules
+    # ------------------------------------------------------------------
+
+    def create_rule(self, payload: Mapping[str, Any]) -> Any:
+        return self._request("POST", "/api/rules", json=payload)
+
+    def list_rules(self, **filters: Any) -> Any:
+        return self._request("GET", "/api/rules", params=_strip_none(filters))
+
+    def get_rule(self, rule_id: str) -> Any:
+        return self._request("GET", f"/api/rules/{rule_id}")
+
+    def update_rule(self, rule_id: str, payload: Mapping[str, Any]) -> Any:
+        return self._request("PATCH", f"/api/rules/{rule_id}", json=payload)
+
+    def delete_rule(self, rule_id: str) -> Any:
+        return self._request("DELETE", f"/api/rules/{rule_id}")
+
+    def list_marketplace_rules(self, **filters: Any) -> Any:
+        return self._request(
+            "GET", "/api/rules/marketplace/list", params=_strip_none(filters)
+        )
+
+    def search_marketplace_rules(self, *, query: str, limit: int = 20) -> Any:
+        params = self._build_params(required={"q": query}, optional={"limit": limit})
+        return self._request("GET", "/api/rules/marketplace/search", params=params)
+
+    def get_top_marketplace_rules(self, *, limit: int = 10) -> Any:
+        params = self._build_params(optional={"limit": limit})
+        return self._request("GET", "/api/rules/marketplace/top", params=params)
+
+    def fork_rule(self, rule_id: str, payload: Mapping[str, Any]) -> Any:
+        return self._request("POST", f"/api/rules/{rule_id}/fork", json=payload)
+
+    def download_rule(self, rule_id: str) -> Any:
+        return self._request("POST", f"/api/rules/{rule_id}/download")
+
+    def rate_rule(self, rule_id: str, rating: float) -> Any:
+        return self._request(
+            "POST", f"/api/rules/{rule_id}/rate", json={"rating": rating}
+        )
+
+    def export_rule(self, rule_id: str, format: str) -> Any:
+        return self._request("GET", f"/api/rules/{rule_id}/export/{format}")
+
+    def export_merged_rules(self, format: str) -> Any:
+        params = self._build_params(required={"format": format})
+        return self._request("GET", "/api/rules/export/merged", params=params)

{fenix_mcp-1.12.0 → fenix_mcp-1.14.0}/fenix_mcp/infrastructure/http_client.py

@@ -12,6 +12,8 @@ from requests import Response, Session
 from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 
+from fenix_mcp.infrastructure.request_context import get_request_token
+
 
 @dataclass(slots=True)
 class HttpClient:
@@ -53,6 +55,11 @@ class HttpClient:
         merged_headers = dict(self.default_headers or {})
         merged_headers.update(headers or {})
 
+        # Use request-scoped token if available (overrides default)
+        request_token = get_request_token()
+        if request_token:
+            merged_headers["Authorization"] = f"Bearer {request_token}"
+
         self._logger.debug(
             "HTTP request",
             extra={

fenix_mcp-1.14.0/fenix_mcp/infrastructure/request_context.py

@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: MIT
+"""Request-scoped context using contextvars for async isolation."""
+
+from __future__ import annotations
+
+from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import Optional
+
+# Context variable for the current request's token
+# This is automatically isolated per async task/request
+_current_token: ContextVar[Optional[str]] = ContextVar("current_token", default=None)
+
+
+@dataclass(slots=True, frozen=True)
+class RequestContext:
+    """Holds request-scoped data like the user's token."""
+
+    token: Optional[str] = None
+    user_id: Optional[str] = None
+    tenant_id: Optional[str] = None
+    team_id: Optional[str] = None
+
+
+def set_request_token(token: Optional[str]) -> None:
+    """Set the token for the current async context/request."""
+    _current_token.set(token)
+
+
+def get_request_token() -> Optional[str]:
+    """Get the token for the current async context/request."""
+    return _current_token.get()
+
+
+def clear_request_token() -> None:
+    """Clear the token for the current async context/request."""
+    _current_token.set(None)

{fenix_mcp-1.12.0 → fenix_mcp-1.14.0}/fenix_mcp/interface/transports.py

@@ -14,6 +14,10 @@ from typing import Iterable, List, Protocol
 from aiohttp import web
 
 from fenix_mcp.infrastructure.config import Settings
+from fenix_mcp.infrastructure.request_context import (
+    set_request_token,
+    clear_request_token,
+)
 
 
 class Transport(Protocol):
@@ -147,17 +151,20 @@ class HttpTransport:
         return self._with_cors(web.Response(status=204))
 
     async def _handle_jsonrpc(self, request: web.Request) -> web.StreamResponse:
+        # Extract token from Authorization header (per-request isolation)
         auth_header = request.headers.get("Authorization") or request.headers.get(
             "authorization"
         )
         if auth_header and auth_header.lower().startswith("bearer "):
             token = auth_header.split(" ", 1)[1].strip()
             if token:
-                self._server.set_personal_access_token(token)
+                # Set token in contextvar (isolated per async request)
+                set_request_token(token)
 
         try:
             payload = await request.json()
         except Exception:  # pragma: no cover - defensive
+            clear_request_token()
             return self._with_cors(
                 web.json_response(
                     {"error": {"code": -32700, "message": "Invalid JSON"}}, status=400
@@ -175,6 +182,9 @@ class HttpTransport:
                     {"error": {"code": -32000, "message": str(exc)}}, status=500
                 )
             )
+        finally:
+            # Clear token after request completes
+            clear_request_token()
 
         if response is None:
             return self._with_cors(web.Response(status=204))

{fenix_mcp-1.12.0 → fenix_mcp-1.14.0}/fenix_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fenix-mcp
-Version: 1.12.0
+Version: 1.14.0
 Summary: Fênix Cloud MCP server implemented in Python
 Author: Fenix Inc
 Requires-Python: >=3.10

{fenix_mcp-1.12.0 → fenix_mcp-1.14.0}/fenix_mcp.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ fenix_mcp/infrastructure/config.py
 fenix_mcp/infrastructure/context.py
 fenix_mcp/infrastructure/http_client.py
 fenix_mcp/infrastructure/logging.py
+fenix_mcp/infrastructure/request_context.py
 fenix_mcp/infrastructure/fenix_api/client.py
 fenix_mcp/interface/mcp_server.py
 fenix_mcp/interface/transports.py