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

fenix_mcp/domain/intelligence.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 
 import asyncio
 from dataclasses import dataclass
-from typing import Any, Dict, Iterable, List, Optional
+from typing import Any, Dict, List, Optional
 
 from fenix_mcp.infrastructure.fenix_api.client import FenixApiClient
 
@@ -15,270 +15,80 @@ class IntelligenceService:
     api: FenixApiClient
     logger: Any
 
-    async def smart_create_memory(
+    async def save_memory(
         self,
         *,
         title: str,
         content: str,
-        metadata: str,
-        context: Optional[str],
-        source: str,
-        importance: str,
         tags: List[str],
+        documentation_item_id: Optional[str] = None,
+        work_item_id: Optional[str] = None,
+        sprint_id: Optional[str] = None,
     ) -> Dict[str, Any]:
-        # Validate required parameters
-        if not metadata or not metadata.strip():
-            raise ValueError("metadata is required and cannot be empty")
-
-        if not source or not source.strip():
-            raise ValueError("source is required and cannot be empty")
-
+        """
+        Smart save memory - creates or updates based on semantic similarity.
+
+        Required:
+        - title: Memory title
+        - content: Memory content
+        - tags: List of tags for categorization
+
+        Optional:
+        - documentation_item_id: Related documentation
+        - work_item_id: Related work item
+        - sprint_id: Related sprint
+        """
+        if not title or not title.strip():
+            raise ValueError("title is required")
+        if not content or not content.strip():
+            raise ValueError("content is required")
         if not tags or not isinstance(tags, list) or len(tags) == 0:
-            raise ValueError("tags is required and must be a non-empty List[str]")
-
-        # Validate all tags are strings
-        for i, tag in enumerate(tags):
-            if not isinstance(tag, str) or not tag.strip():
-                raise ValueError(
-                    f"All tags must be non-empty strings, got {type(tag)} at index {i}"
-                )
+            raise ValueError("tags is required and must be a non-empty list")
 
-        importance_value = importance or "medium"
-        metadata_str = build_metadata(
-            metadata,
-            importance=importance_value,
-            tags=tags,
-            context=context,
-            source=source,
-        )
         payload = {
-            "title": title,
-            "content": content,
-            "metadata": metadata_str,
-            "priority_score": _importance_to_priority(importance_value),
-            "tags": tags,
+            "title": title.strip(),
+            "content": content.strip(),
+            "tags": [t.strip() for t in tags if t.strip()],
         }
-        return await self._call(self.api.smart_create_memory, _strip_none(payload))
 
-    async def query_memories(self, **filters: Any) -> List[Dict[str, Any]]:
-        params = _strip_none(filters)
-        include_content = _coerce_bool(
-            params.pop("include_content", params.pop("content", None))
-        )
-        include_metadata = _coerce_bool(
-            params.pop("include_metadata", params.pop("metadata", None))
-        )
-        allowed_keys = {
-            "limit",
-            "offset",
-            "query",
-            "tags",
-            "modeId",
-            "ruleId",
-            "workItemId",
-            "sprintId",
-            "documentationItemId",
-            "importance",
-        }
-        cleaned_params = {key: params[key] for key in allowed_keys if key in params}
-        return (
-            await self._call(
-                self.api.list_memories,
-                include_content=include_content,
-                include_metadata=include_metadata,
-                **cleaned_params,
-            )
-            or []
-        )
-
-    async def similar_memories(
-        self, *, content: str, threshold: float, max_results: int
-    ) -> List[Dict[str, Any]]:
-        payload = {
-            "content": content,
-            "threshold": threshold,
-        }
-        result = (
-            await self._call(self.api.find_similar_memories, _strip_none(payload)) or []
-        )
-        if isinstance(result, list) and max_results:
-            return result[:max_results]
-        return result
+        if documentation_item_id:
+            payload["documentationItemId"] = documentation_item_id
+        if work_item_id:
+            payload["workItemId"] = work_item_id
+        if sprint_id:
+            payload["sprintId"] = sprint_id
 
-    async def consolidate_memories(
-        self, *, memory_ids: Iterable[str], strategy: str
-    ) -> Dict[str, Any]:
-        payload = {
-            "memoryIds": list(memory_ids),
-            "strategy": strategy,
-        }
-        return await self._call(self.api.consolidate_memories, payload)
+        return await self._call(self.api.save_memory, payload)
 
-    async def update_memory(self, memory_id: str, **fields: Any) -> Dict[str, Any]:
-        payload = _strip_none(fields)
-        if "importance" in payload:
-            payload["priority_score"] = _importance_to_priority(
-                payload.pop("importance")
-            )
-        mapping = {
-            "documentation_item_id": "documentationItemId",
-            "mode_id": "modeId",
-            "rule_id": "ruleId",
-            "work_item_id": "workItemId",
-            "sprint_id": "sprintId",
-        }
-        for old_key, new_key in mapping.items():
-            if old_key in payload:
-                payload[new_key] = payload.pop(old_key)
-        return await self._call(self.api.update_memory, memory_id, payload)
-
-    async def delete_memory(self, memory_id: str) -> None:
-        await self._call(self.api.delete_memory, memory_id)
-
-    async def _call(self, func, *args, **kwargs):
-        return await asyncio.to_thread(func, *args, **kwargs)
-
-    async def get_memory(
+    async def search_memories(
         self,
-        memory_id: str,
         *,
-        include_content: bool = False,
-        include_metadata: bool = False,
-    ) -> Dict[str, Any]:
-        return await self._call(
-            self.api.get_memory,
-            memory_id,
-            include_content=include_content,
-            include_metadata=include_metadata,
-        )
-
-
-def _importance_to_priority(importance: Optional[str]) -> float:
-    mapping = {
-        "low": 0.2,
-        "medium": 0.5,
-        "high": 0.7,
-        "critical": 0.9,
-    }
-    if importance is None:
-        return 0.5
-    return mapping.get(importance.lower(), 0.5)
-
-
-def _coerce_bool(value: Any, default: bool = False) -> bool:
-    if value is None or value == "":
-        return default
-    if isinstance(value, bool):
-        return value
-    if isinstance(value, (int, float)):
-        return bool(value)
-    if isinstance(value, str):
-        normalized = value.strip().lower()
-        if normalized in {"true", "1", "yes", "y"}:
-            return True
-        if normalized in {"false", "0", "no", "n"}:
-            return False
-    return bool(value)
-
-
-def _strip_none(data: Dict[str, Any]) -> Dict[str, Any]:
-    return {key: value for key, value in data.items() if value not in (None, "")}
-
-
-def build_metadata(
-    explicit: str,
-    *,
-    importance: Optional[str],
-    tags: List[str],
-    context: Optional[str] = None,
-    source: str,
-    existing: Optional[str] = None,
-) -> str:
-    if explicit and explicit.strip():
-        return explicit.strip()
-
-    existing_map = _parse_metadata(existing) if existing else {}
-    metadata_map: Dict[str, str] = {}
-
-    metadata_map["t"] = existing_map.get("t", "memory")
-    metadata_map["src"] = _slugify(source) if source else existing_map.get("src", "mcp")
-
-    ctx_value = _slugify(context) if context else existing_map.get("ctx")
-    if ctx_value:
-        metadata_map["ctx"] = ctx_value
-
-    priority_key = importance.lower() if importance else existing_map.get("p")
-    if priority_key:
-        metadata_map["p"] = priority_key
-
-    tag_string = _format_tags(tags)
-    if tag_string:
-        metadata_map["tags"] = tag_string
-    elif "tags" in existing_map:
-        metadata_map["tags"] = existing_map["tags"]
-
-    for key, value in existing_map.items():
-        if key not in metadata_map:
-            metadata_map[key] = value
-
-    if not metadata_map:
-        metadata_map["t"] = "memory"
-        metadata_map["src"] = "mcp"
-
-    return "|".join(f"{key}:{metadata_map[key]}" for key in metadata_map)
-
-
-def _parse_metadata(metadata: str) -> Dict[str, str]:
-    items = {}
-    for entry in metadata.split("|"):
-        if ":" not in entry:
-            continue
-        key, value = entry.split(":", 1)
-        key = key.strip()
-        value = value.strip()
-        if key:
-            items[key] = value
-    return items
-
-
-def _slugify(value: Optional[str]) -> str:
-    if not value:
-        return ""
-    sanitized = value.replace("|", " ").replace(":", " ")
-    return "-".join(part for part in sanitized.split() if part).lower()
-
-
-def _format_tags(tags: List[str]) -> str:
-    """
-    Format tags list into a comma-separated string for metadata.
-
-    Args:
-        tags: List of string tags (required)
+        query: str,
+        limit: int = 5,
+        tags: Optional[List[str]] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Search memories using semantic similarity (embeddings).
 
-    Returns:
-        Comma-separated string of tags
+        Required:
+        - query: Natural language search query
 
-    Raises:
-        TypeError: If tags is not a List[str]
-        ValueError: If tags is empty
-    """
-    if not isinstance(tags, list):
-        raise TypeError(f"tags must be List[str], got {type(tags)}")
+        Optional:
+        - limit: Maximum results (default 5)
+        - tags: Filter by tags
+        """
+        if not query or not query.strip():
+            raise ValueError("query is required")
 
-    if not tags:
-        raise ValueError("tags cannot be empty")
+        payload = {
+            "query": query.strip(),
+            "limit": limit,
+        }
 
-    # Clean and validate tags
-    cleaned_tags = []
-    for tag in tags:
-        if isinstance(tag, str) and tag.strip():
-            cleaned_tags.append(tag.strip())
-        else:
-            raise ValueError(
-                f"All tags must be non-empty strings, got {type(tag)}: {tag}"
-            )
+        if tags:
+            payload["tags"] = [t.strip() for t in tags if t.strip()]
 
-    if not cleaned_tags:
-        raise ValueError("No valid tags found after cleaning")
+        return await self._call(self.api.search_memories, payload) or []
 
-    return ",".join(sorted(set(cleaned_tags)))
+    async def _call(self, func, *args, **kwargs):
+        return await asyncio.to_thread(func, *args, **kwargs)

fenix_mcp/domain/knowledge.py

@@ -466,6 +466,28 @@ class KnowledgeService:
         result = await self._call(self.api.export_rule, rule_id, format)
         return result if isinstance(result, str) else str(result or "")
 
+    # ------------------------------------------------------------------
+    # API Catalog
+    # ------------------------------------------------------------------
+    async def api_catalog_list(self, **filters: Any) -> List[Dict[str, Any]]:
+        return await self._call_list(self.api.list_api_catalog, **_strip_none(filters))
+
+    async def api_catalog_get(self, spec_id: str) -> Dict[str, Any]:
+        return await self._call_dict(self.api.get_api_catalog, spec_id)
+
+    async def api_catalog_search(
+        self,
+        *,
+        query: str,
+        limit: int = 10,
+    ) -> Dict[str, Any]:
+        result = await self._call(
+            self.api.search_api_catalog_semantic,
+            query=query,
+            limit=limit,
+        )
+        return _ensure_dict(result) if isinstance(result, dict) else {"data": result}
+
 
 __all__ = [
     "KnowledgeService",

fenix_mcp/infrastructure/fenix_api/client.py

@@ -228,9 +228,6 @@ class FenixApiClient:
     # Memories
     # ------------------------------------------------------------------
 
-    def create_memory(self, payload: Mapping[str, Any]) -> Any:
-        return self._request("POST", "/api/memories", json=payload)
-
     def list_memories(
         self,
         *,
@@ -259,30 +256,16 @@ class FenixApiClient:
     def update_memory(self, memory_id: str, payload: Mapping[str, Any]) -> Any:
         return self._request("PATCH", f"/api/memories/{memory_id}", json=payload)
 
-    def delete_memory(self, memory_id: str) -> Any:
-        return self._request("DELETE", f"/api/memories/{memory_id}")
-
-    def list_memories_by_tags(self, *, tags: str) -> Any:
-        params = self._build_params(required={"tags": tags})
-        return self._request("GET", "/api/memories/tags", params=params)
-
     def record_memory_access(self, memory_id: str) -> Any:
         return self._request("POST", f"/api/memories/{memory_id}/access")
 
-    def find_similar_memories(self, payload: Mapping[str, Any]) -> Any:
-        return self._request(
-            "POST", "/api/memory-intelligence/similarity", json=payload
-        )
-
-    def consolidate_memories(self, payload: Mapping[str, Any]) -> Any:
-        return self._request(
-            "POST", "/api/memory-intelligence/consolidate", json=payload
-        )
+    def save_memory(self, payload: Mapping[str, Any]) -> Any:
+        """Smart save memory - creates or updates based on semantic similarity."""
+        return self._request("POST", "/api/memories/save", json=payload)
 
-    def smart_create_memory(self, payload: Mapping[str, Any]) -> Any:
-        return self._request(
-            "POST", "/api/memory-intelligence/smart-create", json=payload
-        )
+    def search_memories(self, payload: Mapping[str, Any]) -> Any:
+        """Search memories using semantic similarity (embeddings)."""
+        return self._request("POST", "/api/memories/search", json=payload)
 
     # ------------------------------------------------------------------
     # Knowledge: documentation
@@ -642,3 +625,105 @@ class FenixApiClient:
     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)
+
+    # ------------------------------------------------------------------
+    # API Catalog
+    # ------------------------------------------------------------------
+
+    def list_api_catalog(self, **filters: Any) -> Any:
+        """List API specifications with optional filters."""
+        return self._request("GET", "/api/api-catalog", params=_strip_none(filters))
+
+    def get_api_catalog(self, spec_id: str) -> Any:
+        """Get API specification details by ID."""
+        return self._request("GET", f"/api/api-catalog/{spec_id}")
+
+    def search_api_catalog_text(
+        self,
+        *,
+        query: str,
+        limit: int = 20,
+        offset: int = 0,
+        status: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+    ) -> Any:
+        """Full-text search in API specifications."""
+        params = self._build_params(
+            required={"q": query},
+            optional={
+                "limit": limit,
+                "offset": offset,
+                "status": status,
+                "tags": ",".join(tags) if tags else None,
+            },
+        )
+        return self._request("GET", "/api/api-catalog/search/apis", params=params)
+
+    def search_api_catalog_endpoints_text(
+        self,
+        *,
+        query: str,
+        limit: int = 20,
+        offset: int = 0,
+        specification_id: Optional[str] = None,
+        method: Optional[str] = None,
+    ) -> Any:
+        """Full-text search in API endpoints."""
+        params = self._build_params(
+            required={"q": query},
+            optional={
+                "limit": limit,
+                "offset": offset,
+                "specificationId": specification_id,
+                "method": method,
+            },
+        )
+        return self._request("GET", "/api/api-catalog/search/endpoints", params=params)
+
+    def search_api_catalog_semantic(
+        self,
+        *,
+        query: str,
+        limit: int = 20,
+        offset: int = 0,
+        threshold: Optional[float] = None,
+        status: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+    ) -> Any:
+        """Semantic search in API specifications using embeddings."""
+        params = self._build_params(
+            required={"q": query},
+            optional={
+                "limit": limit,
+                "offset": offset,
+                "threshold": threshold,
+                "status": status,
+                "tags": ",".join(tags) if tags else None,
+            },
+        )
+        return self._request("GET", "/api/api-catalog/semantic/apis", params=params)
+
+    def search_api_catalog_endpoints_semantic(
+        self,
+        *,
+        query: str,
+        limit: int = 20,
+        offset: int = 0,
+        threshold: Optional[float] = None,
+        specification_id: Optional[str] = None,
+        method: Optional[str] = None,
+    ) -> Any:
+        """Semantic search in API endpoints using embeddings."""
+        params = self._build_params(
+            required={"q": query},
+            optional={
+                "limit": limit,
+                "offset": offset,
+                "threshold": threshold,
+                "specificationId": specification_id,
+                "method": method,
+            },
+        )
+        return self._request(
+            "GET", "/api/api-catalog/semantic/endpoints", params=params
+        )

fenix_mcp/interface/mcp_server.py

@@ -63,6 +63,18 @@ class SimpleMcpServer:
             # 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}")