fenix-mcp 0.5.0__tar.gz → 0.5.1__tar.gz

{fenix_mcp-0.5.0 → fenix_mcp-0.5.1}/PKG-INFO

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

{fenix_mcp-0.5.0 → fenix_mcp-0.5.1}/fenix_mcp/__init__.py

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

{fenix_mcp-0.5.0 → fenix_mcp-0.5.1}/fenix_mcp/application/tools/intelligence.py

@@ -155,6 +155,7 @@ 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,
@@ -162,7 +163,7 @@ class IntelligenceTool(Tool):
             context=payload.context,
             source=payload.source,
             importance=payload.importance,
-            tags=payload.tags,
+            tags=normalized_tags,
         )
         lines = [
             "🧠 **Memória criada com sucesso!**",
@@ -259,17 +260,18 @@ class IntelligenceTool(Tool):
         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=payload.tags,
+            tags=normalized_tags,
             existing=existing.get("metadata") if isinstance(existing, dict) else None,
         )
         update_fields: Dict[str, Any] = {
             "title": payload.title,
             "content": payload.content,
             "metadata": metadata,
-            "tags": payload.tags,
+            "tags": normalized_tags,
             "documentation_item_id": payload.documentation_item_id,
             "mode_id": payload.mode_id,
             "rule_id": payload.rule_id,
@@ -313,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-0.5.0 → fenix_mcp-0.5.1}/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
 
@@ -24,13 +24,14 @@ class IntelligenceService:
         context: Optional[str],
         source: Optional[str],
         importance: str,
-        tags: Optional[Iterable[str]] = None,
+        tags: Optional[Union[Iterable[str], str]] = None,
     ) -> Dict[str, Any]:
         importance_value = importance or "medium"
+        normalized_tags = normalize_tags(tags)
         metadata_str = build_metadata(
             metadata,
             importance=importance_value,
-            tags=tags,
+            tags=normalized_tags,
             context=context,
             source=source,
         )
@@ -39,7 +40,7 @@ class IntelligenceService:
             "content": content,
             "metadata": metadata_str,
             "priority_score": _importance_to_priority(importance_value),
-            "tags": list(tags) if tags else None,
+            "tags": normalized_tags,
         }
         return await self._call(self.api.smart_create_memory, _strip_none(payload))
 
@@ -199,7 +200,7 @@ def build_metadata(
     explicit: Optional[str],
     *,
     importance: Optional[str],
-    tags: Optional[Iterable[str]],
+    tags: Optional[Union[Iterable[str], str]],
     context: Optional[str] = None,
     source: Optional[str] = None,
     existing: Optional[str] = None,
@@ -258,12 +259,31 @@ def _slugify(value: Optional[str]) -> str:
     return "-".join(part for part in sanitized.split() if part).lower()
 
 
-def _format_tags(tags: Optional[Iterable[str]]) -> str:
-    if not tags:
+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 tags if isinstance(tag, str) and _slugify(tag)
+        _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.5.0 → fenix_mcp-0.5.1}/fenix_mcp.egg-info/PKG-INFO

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