fenix-mcp 2.0.0__py3-none-any.whl → 2.2.0__py3-none-any.whl

fenix_mcp/__init__.py

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

fenix_mcp/application/prompt_base.py

@@ -0,0 +1,76 @@
+# SPDX-License-Identifier: MIT
+"""Base abstractions for MCP prompts."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class PromptArgument:
+    """Defines an argument that a prompt accepts."""
+
+    name: str
+    description: str
+    required: bool = False
+
+
+@dataclass
+class PromptMessage:
+    """A single message in a prompt response."""
+
+    role: str  # "user" or "assistant"
+    text: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "role": self.role,
+            "content": {"type": "text", "text": self.text},
+        }
+
+
+@dataclass
+class PromptResult:
+    """Result returned by prompts/get."""
+
+    messages: List[PromptMessage] = field(default_factory=list)
+    description: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        result: Dict[str, Any] = {
+            "messages": [m.to_dict() for m in self.messages],
+        }
+        if self.description:
+            result["description"] = self.description
+        return result
+
+
+class Prompt(ABC):
+    """Interface implemented by all prompts."""
+
+    name: str
+    description: str
+    arguments: List[PromptArgument] = []
+
+    def schema(self) -> Dict[str, Any]:
+        """Return JSON schema describing the prompt."""
+        result: Dict[str, Any] = {
+            "name": self.name,
+            "description": self.description,
+        }
+        if self.arguments:
+            result["arguments"] = [
+                {
+                    "name": arg.name,
+                    "description": arg.description,
+                    "required": arg.required,
+                }
+                for arg in self.arguments
+            ]
+        return result
+
+    @abstractmethod
+    def get_messages(self, arguments: Dict[str, Any]) -> PromptResult:
+        """Generate prompt messages based on provided arguments."""

fenix_mcp/application/prompt_registry.py

@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: MIT
+"""Registry that keeps the mapping between prompt names and instances."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, List
+
+from fenix_mcp.application.prompt_base import Prompt, PromptResult
+
+
+class PromptRegistry:
+    """Lookup table for prompt execution."""
+
+    def __init__(self, prompts: Iterable[Prompt]):
+        self._prompts: Dict[str, Prompt] = {}
+        for prompt in prompts:
+            if prompt.name in self._prompts:
+                raise ValueError(f"Duplicate prompt name detected: {prompt.name}")
+            self._prompts[prompt.name] = prompt
+
+    def list_definitions(self) -> List[dict]:
+        """Return list of prompt schemas for prompts/list."""
+        return [prompt.schema() for prompt in self._prompts.values()]
+
+    def get(self, name: str, arguments: Dict[str, Any]) -> PromptResult:
+        """Get prompt messages for prompts/get."""
+        try:
+            prompt = self._prompts[name]
+        except KeyError as exc:
+            raise KeyError(f"Unknown prompt '{name}'") from exc
+        return prompt.get_messages(arguments)
+
+
+def build_default_prompt_registry() -> PromptRegistry:
+    """Build the default prompt registry with all available prompts."""
+    from fenix_mcp.application.prompts import build_prompts
+
+    prompts = build_prompts()
+    return PromptRegistry(prompts)

fenix_mcp/application/prompts/__init__.py

@@ -0,0 +1,28 @@
+# SPDX-License-Identifier: MIT
+"""Prompt implementations for Fenix MCP server."""
+
+from __future__ import annotations
+
+from typing import List
+
+from fenix_mcp.application.prompt_base import Prompt
+from fenix_mcp.application.prompts.memory import FenixMemoryPrompt
+from fenix_mcp.application.prompts.mine import FenixMinePrompt
+from fenix_mcp.application.prompts.rules import FenixRulesPrompt
+
+
+def build_prompts() -> List[Prompt]:
+    """Build and return all available prompts."""
+    return [
+        FenixMemoryPrompt(),
+        FenixMinePrompt(),
+        FenixRulesPrompt(),
+    ]
+
+
+__all__ = [
+    "build_prompts",
+    "FenixMemoryPrompt",
+    "FenixMinePrompt",
+    "FenixRulesPrompt",
+]

fenix_mcp/application/prompts/memory.py

@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: MIT
+"""Fenix Memory prompt - save content to semantic memory."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from fenix_mcp.application.prompt_base import (
+    Prompt,
+    PromptArgument,
+    PromptMessage,
+    PromptResult,
+)
+
+
+class FenixMemoryPrompt(Prompt):
+    """Prompt to save content to Fenix semantic memory."""
+
+    name = "fenix-memory"
+    description = "Save content to Fenix semantic memory for future reference"
+    arguments: List[PromptArgument] = [
+        PromptArgument(
+            name="content",
+            description="The content to save to memory",
+            required=True,
+        ),
+    ]
+
+    def get_messages(self, arguments: Dict[str, Any]) -> PromptResult:
+        content = arguments.get("content", "")
+
+        if not content:
+            return PromptResult(
+                messages=[
+                    PromptMessage(
+                        role="user",
+                        text=(
+                            "I want to save something to Fenix memory but didn't "
+                            "provide content. Please ask me what I want to save."
+                        ),
+                    )
+                ]
+            )
+
+        instruction = f"""Save the following content to Fenix semantic memory using \
+the `mcp__fenix__intelligence` tool with `action: memory_save`.
+
+**Content to save:**
+{content}
+
+**Instructions:**
+1. Create an appropriate title that summarizes the content
+2. Generate relevant tags (at least 2-3 tags)
+3. Use the content as provided for the memory content field
+4. Confirm once saved successfully"""
+
+        return PromptResult(
+            description="Save content to Fenix semantic memory",
+            messages=[PromptMessage(role="user", text=instruction)],
+        )

fenix_mcp/application/prompts/mine.py

@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: MIT
+"""Fenix Mine prompt - list work items assigned to the user."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from fenix_mcp.application.prompt_base import (
+    Prompt,
+    PromptArgument,
+    PromptMessage,
+    PromptResult,
+)
+
+
+class FenixMinePrompt(Prompt):
+    """Prompt to list work items assigned to the current user."""
+
+    name = "fenix-mine"
+    description = "List all work items assigned to me"
+    arguments: List[PromptArgument] = []
+
+    def get_messages(self, arguments: Dict[str, Any]) -> PromptResult:
+        instruction = """List all work items assigned to me using the \
+`mcp__fenix__knowledge` tool with `action: work_mine`.
+
+**Instructions:**
+1. Fetch my assigned work items
+2. Present them in a clear, organized format (table or list)
+3. Include: key, title, status, priority, and type for each item
+4. Group by status if there are many items (e.g., In Progress, Pending, etc.)
+5. Highlight any high-priority or urgent items"""
+
+        return PromptResult(
+            description="List work items assigned to me",
+            messages=[PromptMessage(role="user", text=instruction)],
+        )

fenix_mcp/application/prompts/rules.py

@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: MIT
+"""Fenix Rules prompt - list team coding rules and standards."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from fenix_mcp.application.prompt_base import (
+    Prompt,
+    PromptArgument,
+    PromptMessage,
+    PromptResult,
+)
+
+
+class FenixRulesPrompt(Prompt):
+    """Prompt to list team coding rules and standards."""
+
+    name = "fenix-rules"
+    description = "List team coding rules and standards"
+    arguments: List[PromptArgument] = []
+
+    def get_messages(self, arguments: Dict[str, Any]) -> PromptResult:
+        instruction = """List the team's coding rules and standards using the \
+`mcp__fenix__knowledge` tool with `action: rule_list`.
+
+**Instructions:**
+1. Fetch all active team rules
+2. Present them in a clear, organized format
+3. Include: rule name, description, and scope for each rule
+4. If there are many rules, group them by category or scope
+5. Highlight any rules that are particularly important or frequently referenced"""
+
+        return PromptResult(
+            description="List team coding rules and standards",
+            messages=[PromptMessage(role="user", text=instruction)],
+        )

fenix_mcp/infrastructure/fenix_api/client.py

@@ -127,8 +127,12 @@ class FenixApiClient:
     def get_health(self) -> Any:
         return self._request("GET", "/health")
 
-    def get_profile(self) -> Any:
-        return self._request("GET", "/api/auth/profile")
+    def get_profile(self, *, include_documents: bool = False) -> Any:
+        """Get user profile. Use include_documents=True to include core and user documents."""
+        params = self._build_params(
+            optional={"include": "documents" if include_documents else None}
+        )
+        return self._request("GET", "/api/auth/profile", params=params)
 
     # ------------------------------------------------------------------
     # Core documents (requires PAT authentication)

fenix_mcp/interface/mcp_server.py

@@ -3,10 +3,15 @@
 
 from __future__ import annotations
 
+import asyncio
 import uuid
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, Dict, Optional
 
+from fenix_mcp.application.prompt_registry import (
+    PromptRegistry,
+    build_default_prompt_registry,
+)
 from fenix_mcp.application.tool_registry import ToolRegistry, build_default_registry
 from fenix_mcp.infrastructure.context import AppContext
 
@@ -15,29 +20,108 @@ class McpServerError(RuntimeError):
     pass
 
 
-@dataclass(slots=True)
+@dataclass
 class SimpleMcpServer:
     context: AppContext
     registry: ToolRegistry
+    prompt_registry: PromptRegistry
     session_id: str
+    _init_instructions: Optional[str] = field(default=None, repr=False)
 
     def set_personal_access_token(self, token: Optional[str]) -> None:
         self.context.api_client.update_token(token)
 
+    async def _build_auto_init_instructions(self) -> str:
+        """Load Fenix context automatically on MCP protocol initialize."""
+        api = self.context.api_client
+        logger = self.context.logger
+
+        # Single API call to get profile with documents
+        try:
+            profile = await asyncio.to_thread(api.get_profile, include_documents=True)
+        except Exception as exc:
+            logger.warning("Auto-init API call failed: %s", exc)
+            profile = None
+
+        if profile is None:
+            profile = {}
+
+        core_documents = profile.get("coreDocuments") or []
+        user_documents = profile.get("userDocuments") or []
+
+        # Build context summary
+        user_info = (profile or {}).get("user") or {}
+        tenant_info = (profile or {}).get("tenant") or {}
+        team_info = (profile or {}).get("team") or {}
+
+        lines = [
+            "# Fenix Cloud Context (Auto-initialized)",
+            "",
+            "## User Context",
+            f"- **User**: {user_info.get('name', 'Unknown')} (`{user_info.get('id', 'N/A')}`)",
+            f"- **Tenant**: {tenant_info.get('name', 'Unknown')} (`{tenant_info.get('id', 'N/A')}`)",
+            f"- **Team**: {team_info.get('name', 'Unknown')} (`{team_info.get('id', 'N/A')}`)",
+        ]
+
+        if core_documents:
+            lines.extend(["", "## Core Documents"])
+            for doc in core_documents:
+                name = doc.get("name", "untitled")
+                content = doc.get("content", "")
+                metadata = doc.get("metadata", "")
+                lines.append(f"\n### {name}")
+                if content:
+                    lines.append(content)
+                if metadata:
+                    lines.append(f"\n**Metadata:**\n{metadata}")
+
+        if user_documents:
+            lines.extend(["", "## User Documents"])
+            for doc in user_documents:
+                name = doc.get("name", "untitled")
+                content = doc.get("content", "")
+                lines.append(f"\n### {name}")
+                if content:
+                    lines.append(content)
+
+        lines.extend(
+            [
+                "",
+                "## Available Tools",
+                "Use `mcp__fenix__knowledge` for work items, docs, sprints, rules.",
+                "Use `mcp__fenix__intelligence` for semantic memory search/save.",
+                "Use `mcp__fenix__productivity` for TODOs.",
+            ]
+        )
+
+        return "\n".join(lines)
+
     async def handle(self, request: Dict[str, Any]) -> Optional[Dict[str, Any]]:
         method = request.get("method")
         request_id = request.get("id")
 
         if method == "initialize":
+            # Auto-load Fenix context
+            try:
+                self._init_instructions = await self._build_auto_init_instructions()
+            except Exception as exc:
+                self.context.logger.warning("Auto-init failed: %s", exc)
+                self._init_instructions = None
+
+            result = {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {"tools": {}, "prompts": {}, "logging": {}},
+                "serverInfo": {"name": "fenix_cloud_mcp_py", "version": "0.1.0"},
+                "sessionId": self.session_id,
+            }
+
+            if self._init_instructions:
+                result["instructions"] = self._init_instructions
+
             return {
                 "jsonrpc": "2.0",
                 "id": request_id,
-                "result": {
-                    "protocolVersion": "2024-11-05",
-                    "capabilities": {"tools": {}, "logging": {}},
-                    "serverInfo": {"name": "fenix_cloud_mcp_py", "version": "0.1.0"},
-                    "sessionId": self.session_id,
-                },
+                "result": result,
             }
 
         if method == "tools/list":
@@ -59,6 +143,29 @@ class SimpleMcpServer:
 
             return {"jsonrpc": "2.0", "id": request_id, "result": result}
 
+        if method == "prompts/list":
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": {"prompts": self.prompt_registry.list_definitions()},
+            }
+
+        if method == "prompts/get":
+            params = request.get("params") or {}
+            name = params.get("name")
+            arguments = params.get("arguments") or {}
+
+            if not name:
+                raise McpServerError("Missing prompt name in prompts/get payload")
+
+            prompt_result = self.prompt_registry.get(name, arguments)
+
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": prompt_result.to_dict(),
+            }
+
         if method == "notifications/initialized":
             # Notifications do not require a response
             return None
@@ -80,8 +187,10 @@ class SimpleMcpServer:
 
 def build_server(context: AppContext) -> SimpleMcpServer:
     registry = build_default_registry(context)
+    prompt_registry = build_default_prompt_registry()
     return SimpleMcpServer(
         context=context,
         registry=registry,
+        prompt_registry=prompt_registry,
         session_id=str(uuid.uuid4()),
     )

{fenix_mcp-2.0.0.dist-info → fenix_mcp-2.2.0.dist-info}/METADATA

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

{fenix_mcp-2.0.0.dist-info → fenix_mcp-2.2.0.dist-info}/RECORD

@@ -1,8 +1,14 @@
-fenix_mcp/__init__.py,sha256=ewwBzUPQxM4BTmesnfhTvSBnnkCQQPE4nOkAVo-lKYM,180
+fenix_mcp/__init__.py,sha256=NhyfXjUDYQJ1T_aVSBfzjCFzfSguUe0vqJ-6cyfbZC0,180
 fenix_mcp/main.py,sha256=iJV-9btNMDJMObvcn7wBQdbLLKjkYCQ1ANGEwHGHlMU,2857
 fenix_mcp/application/presenters.py,sha256=fGME54PdCDhTBhXO-JUB9yLdBHiE1aeXLTC2fCuxnxM,689
+fenix_mcp/application/prompt_base.py,sha256=PJ0XB-ao4bj4Hs27beQJewF8if18hufxUUyDn2gDaTU,2023
+fenix_mcp/application/prompt_registry.py,sha256=gTB-lhQgj0Hhq3sPPMfYDxnfwFDlswgC6SGm9mHULWk,1423
 fenix_mcp/application/tool_base.py,sha256=ZCb9g4ij5Hbb0410NEZTYXvPWq-Zkg8ZCsinTa3gCY4,4741
 fenix_mcp/application/tool_registry.py,sha256=bPT5g8GfxG_qu28R1WaDOZHvtmG6TPDvZi8eWj1T9xE,1250
+fenix_mcp/application/prompts/__init__.py,sha256=0wkPoNUYmIQKotam2qE8uGZmCi_CPGEdG8YP0vZ3LqM,721
+fenix_mcp/application/prompts/memory.py,sha256=Nqpxqtk59DJVfv25DFqHwFjTNajGsW3IGTBflFplFQc,1869
+fenix_mcp/application/prompts/mine.py,sha256=qYOaAckJxXk8diZ7LZp6f0vCbl15AxuR48SZzA7yVXk,1215
+fenix_mcp/application/prompts/rules.py,sha256=RMI14UWfJls8tsr9fZtNSCnF4mCgfz0Wu4H1GjMhEjo,1219
 fenix_mcp/application/tools/__init__.py,sha256=Gi1YvYh-KdL9HD8gLVrknHrxiKKEOhHBEZ02KBXJaKQ,796
 fenix_mcp/application/tools/health.py,sha256=m5DxhoRbdwl6INzd6PISxv1NAv-ljCrezsr773VB0wE,834
 fenix_mcp/application/tools/initialize.py,sha256=YQpZ0K6uz_LiLdE_GdQ0uJKtj6cgFru38xwoaCl5Jmg,5146
@@ -20,11 +26,11 @@ fenix_mcp/infrastructure/context.py,sha256=kiDiamiPbHZpTGyZMylcQwtLhfaDXrxAkWSst
 fenix_mcp/infrastructure/http_client.py,sha256=uJwt_iBGSFa1XPFBeqtm7eznkEm8aZ1v2DSxYjloAQs,2753
 fenix_mcp/infrastructure/logging.py,sha256=bHrWlSi_0HshRe3--BK_5nzUszW-gh37q6jsd0ShS2Y,1371
 fenix_mcp/infrastructure/request_context.py,sha256=hAHXHh-SKizBN7-YgdaRv0JsRYXBdurO2sr9btHPjKI,1101
-fenix_mcp/infrastructure/fenix_api/client.py,sha256=fkXIzo2_Qs4AfnkPX8Z1k-3dwTTJ5wEG-MBCfUZ8Axo,29119
-fenix_mcp/interface/mcp_server.py,sha256=xSIMZwOaEwHLJ1BKy_agdMiep7HFhIgsUhOVz49DsyA,2728
+fenix_mcp/infrastructure/fenix_api/client.py,sha256=rKezcAalo4_qKrXvayK62FO95vuxinn5r6R7eLIDjuc,29389
+fenix_mcp/interface/mcp_server.py,sha256=pEG1xQF0apw1YkVYx-lA0PsLZ8nrGTJrYj_RyX45SdE,6699
 fenix_mcp/interface/transports.py,sha256=2zJtc-L73zasyiwQoZbvFJ0yT1bggL5WAa7Nm7zID3k,8502
-fenix_mcp-2.0.0.dist-info/METADATA,sha256=6oZbIkzpboBC9i1IzXjedPEo_mSECyo_9tbZ36oHQFA,7714
-fenix_mcp-2.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-fenix_mcp-2.0.0.dist-info/entry_points.txt,sha256=o52x_YHBupEd-1Z1GSfUjv3gJrx5_I-EkHhCgt1WBaE,49
-fenix_mcp-2.0.0.dist-info/top_level.txt,sha256=2G1UtKpwjaIGQyE7sRoHecxaGLeuexfjrOUjv9DDKh4,10
-fenix_mcp-2.0.0.dist-info/RECORD,,
+fenix_mcp-2.2.0.dist-info/METADATA,sha256=RyNU85E6X0qAI4rnBWq5qmPL76L9FVLlMkmZGv7Mehc,7714
+fenix_mcp-2.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+fenix_mcp-2.2.0.dist-info/entry_points.txt,sha256=o52x_YHBupEd-1Z1GSfUjv3gJrx5_I-EkHhCgt1WBaE,49
+fenix_mcp-2.2.0.dist-info/top_level.txt,sha256=2G1UtKpwjaIGQyE7sRoHecxaGLeuexfjrOUjv9DDKh4,10
+fenix_mcp-2.2.0.dist-info/RECORD,,