fenix-mcp 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

fenix_mcp/__init__.py

@@ -17,4 +17,4 @@ Updated with improved error handling and better documentation.
 
 __all__ = ["__version__"]
 
-__version__ = "0.4.0"
+__version__ = "0.5.1"

fenix_mcp/application/tools/intelligence.py

@@ -10,7 +10,7 @@ from pydantic import Field
 
 from fenix_mcp.application.presenters import text
 from fenix_mcp.application.tool_base import Tool, ToolRequest
-from fenix_mcp.domain.intelligence import IntelligenceService
+from fenix_mcp.domain.intelligence import IntelligenceService, build_metadata
 from fenix_mcp.infrastructure.context import AppContext
 
 
@@ -66,10 +66,14 @@ class IntelligenceRequest(ToolRequest):
     content: Optional[str] = Field(
         default=None, description="Conteúdo/texto da memória."
     )
+    metadata: Optional[str] = Field(
+        default=None,
+        description="Metadata estruturada da memória (formato pipe, toml compacto, etc.).",
+    )
     context: Optional[str] = Field(default=None, description="Contexto adicional.")
     source: Optional[str] = Field(default=None, description="Fonte da memória.")
-    importance: str = Field(
-        default="medium", description="Nível de importância da memória."
+    importance: Optional[str] = Field(
+        default=None, description="Nível de importância da memória."
     )
     include_content: bool = Field(
         default=False,
@@ -151,13 +155,15 @@ class IntelligenceTool(Tool):
     async def _handle_smart_create(self, payload: IntelligenceRequest):
         if not payload.title or not payload.content:
             return text("❌ Informe título e conteúdo para criar uma memória.")
+        normalized_tags = _ensure_tag_sequence(payload.tags)
         memory = await self._service.smart_create_memory(
             title=payload.title,
             content=payload.content,
+            metadata=payload.metadata,
             context=payload.context,
             source=payload.source,
             importance=payload.importance,
-            tags=payload.tags,
+            tags=normalized_tags,
         )
         lines = [
             "🧠 **Memória criada com sucesso!**",
@@ -251,10 +257,21 @@ class IntelligenceTool(Tool):
     async def _handle_update(self, payload: IntelligenceRequest):
         if not payload.id:
             return text("❌ Informe o ID da memória para atualização.")
+        existing = await self._service.get_memory(
+            payload.id, include_content=False, include_metadata=True
+        )
+        normalized_tags = _ensure_tag_sequence(payload.tags)
+        metadata = build_metadata(
+            payload.metadata,
+            importance=payload.importance,
+            tags=normalized_tags,
+            existing=existing.get("metadata") if isinstance(existing, dict) else None,
+        )
         update_fields: Dict[str, Any] = {
             "title": payload.title,
             "content": payload.content,
-            "tags": payload.tags,
+            "metadata": metadata,
+            "tags": normalized_tags,
             "documentation_item_id": payload.documentation_item_id,
             "mode_id": payload.mode_id,
             "rule_id": payload.rule_id,
@@ -298,3 +315,15 @@ def format_percentage(value: Optional[float]) -> str:
     if value is None:
         return "N/A"
     return f"{value * 100:.1f}%"
+
+
+def _ensure_tag_sequence(raw: Optional[Any]) -> Optional[List[str]]:
+    if raw is None or raw == "":
+        return None
+    if isinstance(raw, (list, tuple, set)):
+        result = [str(item).strip() for item in raw if str(item).strip()]
+        return result or None
+    if isinstance(raw, str):
+        items = [part.strip() for part in raw.split(",") if part.strip()]
+        return items or None
+    return [str(raw).strip()]

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, Iterable, List, Optional, Union
 
 from fenix_mcp.infrastructure.fenix_api.client import FenixApiClient
 
@@ -20,23 +20,27 @@ class IntelligenceService:
         *,
         title: str,
         content: str,
+        metadata: Optional[str],
         context: Optional[str],
         source: Optional[str],
         importance: str,
-        tags: Optional[Iterable[str]] = None,
+        tags: Optional[Union[Iterable[str], str]] = None,
     ) -> Dict[str, Any]:
-        metadata_parts: List[str] = []
-        if context:
-            metadata_parts.append(f"Contexto: {context}")
-        if source:
-            metadata_parts.append(f"Fonte: {source}")
-
+        importance_value = importance or "medium"
+        normalized_tags = normalize_tags(tags)
+        metadata_str = build_metadata(
+            metadata,
+            importance=importance_value,
+            tags=normalized_tags,
+            context=context,
+            source=source,
+        )
         payload = {
             "title": title,
             "content": content,
-            "metadata": "\n".join(metadata_parts) if metadata_parts else None,
-            "priority_score": _importance_to_priority(importance),
-            "tags": list(tags) if tags else None,
+            "metadata": metadata_str,
+            "priority_score": _importance_to_priority(importance_value),
+            "tags": normalized_tags,
         }
         return await self._call(self.api.smart_create_memory, _strip_none(payload))
 
@@ -145,6 +149,20 @@ class IntelligenceService:
     async def _call(self, func, *args, **kwargs):
         return await asyncio.to_thread(func, *args, **kwargs)
 
+    async def get_memory(
+        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 = {
@@ -176,3 +194,96 @@ def _coerce_bool(value: Any, default: bool = False) -> bool:
 
 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: Optional[str],
+    *,
+    importance: Optional[str],
+    tags: Optional[Union[Iterable[str], str]],
+    context: Optional[str] = None,
+    source: Optional[str] = None,
+    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: Optional[Union[Iterable[str], str]]) -> str:
+    if tags is None or tags == "":
+        return ""
+    if isinstance(tags, str):
+        iterable: Iterable[str] = [part.strip() for part in tags.split(",")]
+    else:
+        iterable = tags
+    normalized = {
+        _slugify(tag) for tag in iterable if isinstance(tag, str) and _slugify(tag)
+    }
+    if not normalized:
+        return ""
+    return ",".join(sorted(normalized))
+
+
+def normalize_tags(tags: Optional[Union[Iterable[str], str]]) -> Optional[List[str]]:
+    if tags is None or tags == "":
+        return None
+    if isinstance(tags, str):
+        parts = [part.strip() for part in tags.split(",") if part.strip()]
+    else:
+        parts = [str(part).strip() for part in tags if str(part).strip()]
+    if not parts:
+        return None
+    slugged = [_slugify(part) for part in parts if _slugify(part)]
+    if not slugged:
+        return None
+    return sorted(set(slugged))

{fenix_mcp-0.4.0.dist-info → fenix_mcp-0.5.1.dist-info}/METADATA

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

{fenix_mcp-0.4.0.dist-info → fenix_mcp-0.5.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-fenix_mcp/__init__.py,sha256=RC_GHV0oxTvs3Y2i7XSIUtYYtjwepfTw40Tcnx2CdfU,615
+fenix_mcp/__init__.py,sha256=Nle0-p8uRDw1ypGPxnoKnAY0Mv0N8_6glE1whGPNnlw,615
 fenix_mcp/main.py,sha256=iJV-9btNMDJMObvcn7wBQdbLLKjkYCQ1ANGEwHGHlMU,2857
 fenix_mcp/application/presenters.py,sha256=fGME54PdCDhTBhXO-JUB9yLdBHiE1aeXLTC2fCuxnxM,689
 fenix_mcp/application/tool_base.py,sha256=qUcb46qx9gHQfrSHgj4RD4NCHW-OIvKQdR5G9uxZ5l4,1316
@@ -6,12 +6,12 @@ fenix_mcp/application/tool_registry.py,sha256=bPT5g8GfxG_qu28R1WaDOZHvtmG6TPDvZi
 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=f33DNDn9u8IYwpqiBj6bjJ-wHgaUP1zEuAvUM1rMYPc,4674
-fenix_mcp/application/tools/intelligence.py,sha256=oRGmmaeRJG_6ckZaByAdZbMKmr2E1cZPxGeFwSFaCTE,12761
+fenix_mcp/application/tools/intelligence.py,sha256=DNWGu6NhPYZXahnHDVHIgYYdWn_jCP-Nw9FwS_Tat34,13945
 fenix_mcp/application/tools/knowledge.py,sha256=4ClGoFRqyFIPuzzg2DAg-w2eMvTP37mH0THXDGftinw,44634
 fenix_mcp/application/tools/productivity.py,sha256=2IMkNdZ-Kd1CFAO7geruAVjtf_BWoDdbnwkl76vhtC8,9973
 fenix_mcp/application/tools/user_config.py,sha256=8mPOZuwszO0TapxgrA7Foe15VQE874_mvfQYlGzyv4Y,6230
 fenix_mcp/domain/initialization.py,sha256=AZhdSNITQ7O3clELBuqGvjJc-c8pFKc7zQz-XR2xXPc,6933
-fenix_mcp/domain/intelligence.py,sha256=rOQWxtEceTWGlnWMfUXrBTzjt-yATrMPgFktWF1L5QA,5707
+fenix_mcp/domain/intelligence.py,sha256=IyZUA_fbCHDgHaWCgxkahXAaAT5qQlaz5AT7Cw2Gwko,9006
 fenix_mcp/domain/knowledge.py,sha256=fKQOTt20u5aa5Yo7gPeQ1Qxa_K5pBxn1yn8FEfOFltM,20241
 fenix_mcp/domain/productivity.py,sha256=nmHRuVJGRRu1s4eMoAv8vXHKsSauCPl-FvFx3I_yCTE,6661
 fenix_mcp/domain/user_config.py,sha256=LzBDCk31gLMtKHTbBmYb9VoFPHDW6OydpmDXeHHd0Mw,1642
@@ -22,8 +22,8 @@ fenix_mcp/infrastructure/logging.py,sha256=bHrWlSi_0HshRe3--BK_5nzUszW-gh37q6jsd
 fenix_mcp/infrastructure/fenix_api/client.py,sha256=Navi7cGAOradghcbYkFIQQINpjFrdINlNhdfZ4iSSYQ,28338
 fenix_mcp/interface/mcp_server.py,sha256=5UM2NJuNbwHkmCEprIFataJ5nFZiO8efTtP_oW3_iX0,2331
 fenix_mcp/interface/transports.py,sha256=PxdhfjH8UMl03f7nuCLc-M6tMx6-Y-btVz_mSqXKrSI,8138
-fenix_mcp-0.4.0.dist-info/METADATA,sha256=fIm7WGYy9JK5VwYIlc_iFWgLVh6XuNFvGJKkPrjS3O0,7260
-fenix_mcp-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fenix_mcp-0.4.0.dist-info/entry_points.txt,sha256=o52x_YHBupEd-1Z1GSfUjv3gJrx5_I-EkHhCgt1WBaE,49
-fenix_mcp-0.4.0.dist-info/top_level.txt,sha256=2G1UtKpwjaIGQyE7sRoHecxaGLeuexfjrOUjv9DDKh4,10
-fenix_mcp-0.4.0.dist-info/RECORD,,
+fenix_mcp-0.5.1.dist-info/METADATA,sha256=yvg8J1G-jemzju-BKR2tMd8Y_f5KKjHX6GrNQIONjR0,7260
+fenix_mcp-0.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fenix_mcp-0.5.1.dist-info/entry_points.txt,sha256=o52x_YHBupEd-1Z1GSfUjv3gJrx5_I-EkHhCgt1WBaE,49
+fenix_mcp-0.5.1.dist-info/top_level.txt,sha256=2G1UtKpwjaIGQyE7sRoHecxaGLeuexfjrOUjv9DDKh4,10
+fenix_mcp-0.5.1.dist-info/RECORD,,