fenix-mcp 2.0.0__tar.gz → 2.2.0__tar.gz

{fenix_mcp-2.0.0 → fenix_mcp-2.2.0}/PKG-INFO

@@ -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 → fenix_mcp-2.2.0}/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-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-2.2.0/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-2.2.0/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-2.2.0/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-2.2.0/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-2.2.0/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-2.0.0 → fenix_mcp-2.2.0}/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-2.2.0/fenix_mcp/interface/mcp_server.py

@@ -0,0 +1,196 @@
+# SPDX-License-Identifier: MIT
+"""Lightweight MCP server implementation backed by the tool registry."""
+
+from __future__ import annotations
+
+import asyncio
+import uuid
+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
+
+
+class McpServerError(RuntimeError):
+    pass
+
+
+@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": result,
+            }
+
+        if method == "tools/list":
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": {"tools": self.registry.list_definitions()},
+            }
+
+        if method == "tools/call":
+            params = request.get("params") or {}
+            name = params.get("name")
+            arguments = params.get("arguments") or {}
+
+            if not name:
+                raise McpServerError("Missing tool name in tools/call payload")
+
+            result = await self.registry.execute(name, arguments, self.context)
+
+            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
+
+        if method == "notifications/cancelled":
+            # Client cancelled a request - no response needed
+            return None
+
+        if method == "logging/setLevel":
+            # Acknowledge log level change request (we don't actually change anything)
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": {},
+            }
+
+        raise McpServerError(f"Unsupported method: {method}")
+
+
+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 → fenix_mcp-2.2.0}/fenix_mcp.egg-info/PKG-INFO

@@ -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 → fenix_mcp-2.2.0}/fenix_mcp.egg-info/SOURCES.txt

@@ -9,8 +9,14 @@ fenix_mcp.egg-info/entry_points.txt
 fenix_mcp.egg-info/requires.txt
 fenix_mcp.egg-info/top_level.txt
 fenix_mcp/application/presenters.py
+fenix_mcp/application/prompt_base.py
+fenix_mcp/application/prompt_registry.py
 fenix_mcp/application/tool_base.py
 fenix_mcp/application/tool_registry.py
+fenix_mcp/application/prompts/__init__.py
+fenix_mcp/application/prompts/memory.py
+fenix_mcp/application/prompts/mine.py
+fenix_mcp/application/prompts/rules.py
 fenix_mcp/application/tools/__init__.py
 fenix_mcp/application/tools/health.py
 fenix_mcp/application/tools/initialize.py

fenix_mcp-2.0.0/fenix_mcp/interface/mcp_server.py

@@ -1,87 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""Lightweight MCP server implementation backed by the tool registry."""
-
-from __future__ import annotations
-
-import uuid
-from dataclasses import dataclass
-from typing import Any, Dict, Optional
-
-from fenix_mcp.application.tool_registry import ToolRegistry, build_default_registry
-from fenix_mcp.infrastructure.context import AppContext
-
-
-class McpServerError(RuntimeError):
-    pass
-
-
-@dataclass(slots=True)
-class SimpleMcpServer:
-    context: AppContext
-    registry: ToolRegistry
-    session_id: str
-
-    def set_personal_access_token(self, token: Optional[str]) -> None:
-        self.context.api_client.update_token(token)
-
-    async def handle(self, request: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        method = request.get("method")
-        request_id = request.get("id")
-
-        if method == "initialize":
-            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,
-                },
-            }
-
-        if method == "tools/list":
-            return {
-                "jsonrpc": "2.0",
-                "id": request_id,
-                "result": {"tools": self.registry.list_definitions()},
-            }
-
-        if method == "tools/call":
-            params = request.get("params") or {}
-            name = params.get("name")
-            arguments = params.get("arguments") or {}
-
-            if not name:
-                raise McpServerError("Missing tool name in tools/call payload")
-
-            result = await self.registry.execute(name, arguments, self.context)
-
-            return {"jsonrpc": "2.0", "id": request_id, "result": result}
-
-        if method == "notifications/initialized":
-            # Notifications do not require a response
-            return None
-
-        if method == "notifications/cancelled":
-            # Client cancelled a request - no response needed
-            return None
-
-        if method == "logging/setLevel":
-            # Acknowledge log level change request (we don't actually change anything)
-            return {
-                "jsonrpc": "2.0",
-                "id": request_id,
-                "result": {},
-            }
-
-        raise McpServerError(f"Unsupported method: {method}")
-
-
-def build_server(context: AppContext) -> SimpleMcpServer:
-    registry = build_default_registry(context)
-    return SimpleMcpServer(
-        context=context,
-        registry=registry,
-        session_id=str(uuid.uuid4()),
-    )