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

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

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

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

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

{fenix_mcp-0.3.0 → fenix_mcp-0.5.0}/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,22 @@ 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,
+        description="Retornar conteúdo completo das memórias? Defina true para incluir o texto integral.",
+    )
+    include_metadata: bool = Field(
+        default=False,
+        description="Retornar metadata completa das memórias? Defina true para incluir o campo bruto.",
     )
     tags: Optional[List[str]] = Field(default=None, description="Tags da memória.")
     limit: int = Field(default=20, ge=1, le=100, description="Limite de resultados.")
@@ -146,6 +158,7 @@ class IntelligenceTool(Tool):
         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,
@@ -167,6 +180,8 @@ class IntelligenceTool(Tool):
             offset=payload.offset,
             query=payload.query,
             tags=payload.tags,
+            include_content=payload.include_content,
+            include_metadata=payload.include_metadata,
             modeId=payload.mode_id,
             ruleId=payload.rule_id,
             workItemId=payload.work_item_id,
@@ -241,9 +256,19 @@ 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
+        )
+        metadata = build_metadata(
+            payload.metadata,
+            importance=payload.importance,
+            tags=payload.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,
             "documentation_item_id": payload.documentation_item_id,
             "mode_id": payload.mode_id,

{fenix_mcp-0.3.0 → fenix_mcp-0.5.0}/fenix_mcp/domain/intelligence.py

@@ -20,30 +20,37 @@ class IntelligenceService:
         *,
         title: str,
         content: str,
+        metadata: Optional[str],
         context: Optional[str],
         source: Optional[str],
         importance: str,
         tags: Optional[Iterable[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"
+        metadata_str = build_metadata(
+            metadata,
+            importance=importance_value,
+            tags=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),
+            "metadata": metadata_str,
+            "priority_score": _importance_to_priority(importance_value),
             "tags": list(tags) if tags else None,
         }
         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 = bool(params.pop("content", False))
-        include_metadata = bool(params.pop("metadata", False))
+        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",
@@ -141,6 +148,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 = {
@@ -154,5 +175,95 @@ def _importance_to_priority(importance: Optional[str]) -> float:
     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: Optional[str],
+    *,
+    importance: Optional[str],
+    tags: Optional[Iterable[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[Iterable[str]]) -> str:
+    if not tags:
+        return ""
+    normalized = {
+        _slugify(tag) for tag in tags if isinstance(tag, str) and _slugify(tag)
+    }
+    if not normalized:
+        return ""
+    return ",".join(sorted(normalized))

{fenix_mcp-0.3.0 → fenix_mcp-0.5.0}/fenix_mcp.egg-info/PKG-INFO

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