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

fenix_mcp/domain/initialization.py

@@ -15,7 +15,7 @@ class InitializationData:
     profile: Optional[Dict[str, Any]]
     core_documents: List[Dict[str, Any]]
     user_documents: List[Dict[str, Any]]
-    recent_memories: List[Dict[str, Any]]
+    my_work_items: List[Dict[str, Any]]
 
 
 class InitializationService:
@@ -25,9 +25,7 @@ class InitializationService:
         self._api = api_client
         self._logger = logger
 
-    async def gather_data(
-        self, *, include_user_docs: bool, limit: int
-    ) -> InitializationData:
+    async def gather_data(self, *, include_user_docs: bool) -> InitializationData:
         profile = await self._safe_call(self._api.get_profile)
         core_docs = await self._safe_call(
             self._api.list_core_documents,
@@ -46,11 +44,19 @@ class InitializationService:
             )
             if self._logger:
                 self._logger.debug("User docs response", extra={"user_docs": user_docs})
+
+        # Fetch user's assigned work items for proactive context
+        work_items_response = await self._safe_call(
+            self._api.get_work_items_mine,
+            limit=10,
+        )
+        my_work_items = self._extract_items(work_items_response, "workItems")
+
         return InitializationData(
             profile=profile,
             core_documents=self._extract_items(core_docs, "coreDocuments"),
             user_documents=self._extract_items(user_docs, "userCoreDocuments"),
-            recent_memories=[],
+            my_work_items=my_work_items,
         )
 
     async def _safe_call(self, func, *args, **kwargs):
@@ -71,110 +77,3 @@ class InitializationService:
             if isinstance(value, list):
                 return [item for item in value if isinstance(item, dict)]
         return []
-
-    @staticmethod
-    def build_existing_user_summary(
-        data: InitializationData, include_user_docs: bool
-    ) -> str:
-        profile = data.profile or {}
-        user_info = profile.get("user") or {}
-        tenant_info = profile.get("tenant") or {}
-        core_count = len(data.core_documents)
-        user_count = len(data.user_documents)
-        memories_count = len(data.recent_memories)
-
-        lines = [
-            "✅ **Fênix Cloud inicializado com sucesso!**",
-        ]
-
-        if user_info:
-            lines.append(
-                f"- Usuário: {user_info.get('name') or 'Desconhecido'} "
-                f"(ID: {user_info.get('id', 'N/A')})"
-            )
-        if tenant_info:
-            lines.append(f"- Organização: {tenant_info.get('name', 'N/A')}")
-
-        lines.append(f"- Documentos principais carregados: {core_count}")
-
-        if include_user_docs:
-            lines.append(f"- Documentos pessoais carregados: {user_count}")
-
-        lines.append(f"- Memórias recentes disponíveis: {memories_count}")
-
-        if core_count:
-            preview = ", ".join(
-                doc.get("name", doc.get("title", "sem título"))
-                for doc in data.core_documents[:5]
-            )
-            lines.append(f"- Exemplos de documentos principais: {preview}")
-
-        if include_user_docs and user_count:
-            preview = ", ".join(
-                doc.get("name", "sem título") for doc in data.user_documents[:5]
-            )
-            lines.append(f"- Exemplos de documentos pessoais: {preview}")
-
-        if memories_count:
-            preview = ", ".join(
-                mem.get("title", "sem título") for mem in data.recent_memories[:3]
-            )
-            lines.append(f"- Memórias recentes: {preview}")
-
-        lines.append("")
-        lines.append(
-            "Agora você pode usar as ferramentas de produtividade, conhecimento e inteligência para continuar."
-        )
-        return "\n".join(lines)
-
-    @staticmethod
-    def build_new_user_prompt(data: InitializationData) -> str:
-        profile = data.profile or {}
-        user_name = (profile.get("user") or {}).get("name") or "Bem-vindo(a)"
-
-        questions = [
-            "Qual é o foco principal do seu trabalho atualmente?",
-            "Quais são seus objetivos para as próximas semanas?",
-            "Existem tarefas ou projetos que gostaria de priorizar?",
-            "Como você prefere organizar suas rotinas ou checklists?",
-            "Quais são os principais blocos de conhecimento que precisa acessar rapidamente?",
-            "Há regras ou procedimentos que precisam ser seguidos com frequência?",
-            "Que tipo de memória ou registro você consulta com frequência?",
-            "Quais ferramentas ou integrações externas são essenciais no seu dia a dia?",
-            "O que significaria sucesso para você utilizando o Fênix?",
-        ]
-
-        body = [
-            f"👋 **{user_name}, bem-vindo(a) ao Fênix Cloud!**",
-            "",
-            "Notamos que você ainda não tem documentos pessoais configurados. "
-            "Vamos criar uma experiência personalizada para você.",
-            "",
-            "Responda às perguntas abaixo para que possamos preparar modos, regras e documentos alinhados às suas necessidades:",
-            "",
-        ]
-
-        body.extend(f"{idx + 1}. {question}" for idx, question in enumerate(questions))
-        body.extend(
-            [
-                "",
-                "Envie as respostas no formato:",
-                "```",
-                'initialize action=setup answers=["resposta 1", "resposta 2", ..., "resposta 9"]',
-                "```",
-                "",
-                "Com base nisso, sugerirei documentos, regras e rotinas para você utilizar.",
-            ]
-        )
-
-        return "\n".join(body)
-
-    @staticmethod
-    def validate_setup_answers(answers: List[str]) -> Optional[str]:
-        if not answers:
-            return "Envie uma lista com 9 respostas para processarmos o setup."
-        if len(answers) != 9:
-            return f"Esperado receber 9 respostas, mas recebi {len(answers)}."
-        if not all(isinstance(answer, str) and answer.strip() for answer in answers):
-            return "Todas as respostas devem ser textos preenchidos."
-        return None

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

@@ -360,123 +360,6 @@ class KnowledgeService:
     async def sprint_cancel(self, sprint_id: str) -> Dict[str, Any]:
         return await self._call(self.api.cancel_sprint, sprint_id)
 
-    # ------------------------------------------------------------------
-    # Modes and rules
-    # ------------------------------------------------------------------
-    async def mode_create(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        result = await self._call(self.api.create_mode, _strip_none(payload))
-        # API returns { message, mode } - extract mode
-        if isinstance(result, dict) and "mode" in result:
-            return result["mode"]
-        return result or {}
-
-    async def mode_list(
-        self,
-        *,
-        include_rules: Optional[bool] = None,
-        return_description: Optional[bool] = None,
-        return_metadata: Optional[bool] = None,
-    ) -> List[Dict[str, Any]]:
-        return (
-            await self._call(
-                self.api.list_modes,
-                include_rules=include_rules,
-                return_description=return_description,
-                return_metadata=return_metadata,
-            )
-            or []
-        )
-
-    async def mode_get(
-        self,
-        mode_id: str,
-        *,
-        return_description: Optional[bool] = None,
-        return_metadata: Optional[bool] = None,
-    ) -> Dict[str, Any]:
-        return await self._call(
-            self.api.get_mode,
-            mode_id,
-            return_description=return_description,
-            return_metadata=return_metadata,
-        )
-
-    async def mode_update(
-        self, mode_id: str, payload: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        result = await self._call(self.api.update_mode, mode_id, _strip_none(payload))
-        # API returns { message, mode } - extract mode
-        if isinstance(result, dict) and "mode" in result:
-            return result["mode"]
-        return result or {}
-
-    async def mode_delete(self, mode_id: str) -> None:
-        await self._call(self.api.delete_mode, mode_id)
-
-    async def mode_rule_add(self, mode_id: str, rule_id: str) -> Dict[str, Any]:
-        return await self._call(self.api.add_mode_rule, mode_id, rule_id)
-
-    async def mode_rule_remove(self, mode_id: str, rule_id: str) -> None:
-        await self._call(self.api.remove_mode_rule, mode_id, rule_id)
-
-    async def mode_rules(self, mode_id: str) -> List[Dict[str, Any]]:
-        return await self._call(self.api.list_rules_by_mode, mode_id) or []
-
-    async def mode_rules_for_rule(self, rule_id: str) -> List[Dict[str, Any]]:
-        return await self._call(self.api.list_modes_by_rule, rule_id) or []
-
-    async def rule_create(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        result = await self._call(self.api.create_rule, _strip_none(payload))
-        # API returns { message, rule } - extract rule
-        if isinstance(result, dict) and "rule" in result:
-            return result["rule"]
-        return result or {}
-
-    async def rule_list(
-        self,
-        *,
-        return_description: Optional[bool] = None,
-        return_metadata: Optional[bool] = None,
-        return_modes: Optional[bool] = None,
-    ) -> List[Dict[str, Any]]:
-        return (
-            await self._call(
-                self.api.list_rules,
-                return_description=return_description,
-                return_metadata=return_metadata,
-                return_modes=return_modes,
-            )
-            or []
-        )
-
-    async def rule_get(
-        self,
-        rule_id: str,
-        *,
-        return_description: Optional[bool] = None,
-        return_metadata: Optional[bool] = None,
-        return_modes: Optional[bool] = None,
-    ) -> Dict[str, Any]:
-        return await self._call(
-            self.api.get_rule,
-            rule_id,
-            return_description=return_description,
-            return_metadata=return_metadata,
-            return_modes=return_modes,
-        )
-
-    async def rule_update(
-        self, rule_id: str, payload: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        result = await self._call(self.api.update_rule, rule_id, _strip_none(payload))
-        # API returns { message, rule } - extract rule
-        if isinstance(result, dict) and "rule" in result:
-            return result["rule"]
-        return result or {}
-
-    async def rule_delete(self, rule_id: str) -> None:
-        await self._call(self.api.delete_rule, rule_id)
-
     # ------------------------------------------------------------------
     # Documentation
     # ------------------------------------------------------------------
@@ -549,6 +432,62 @@ class KnowledgeService:
             self.api.duplicate_documentation_item, doc_id, _strip_none(payload)
         )
 
+    # ------------------------------------------------------------------
+    # Rules
+    # ------------------------------------------------------------------
+    async def rule_create(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        return await self._call_dict(self.api.create_rule, _strip_none(payload))
+
+    async def rule_list(self, **filters: Any) -> List[Dict[str, Any]]:
+        return await self._call_list(self.api.list_rules, **_strip_none(filters))
+
+    async def rule_get(self, rule_id: str) -> Dict[str, Any]:
+        return await self._call_dict(self.api.get_rule, rule_id)
+
+    async def rule_update(
+        self, rule_id: str, payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        return await self._call_dict(
+            self.api.update_rule, rule_id, _strip_none(payload)
+        )
+
+    async def rule_delete(self, rule_id: str) -> None:
+        await self._call(self.api.delete_rule, rule_id)
+
+    async def rule_marketplace(self, **filters: Any) -> List[Dict[str, Any]]:
+        return await self._call_list(
+            self.api.list_marketplace_rules, **_strip_none(filters)
+        )
+
+    async def rule_fork(self, rule_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        return await self._call_dict(self.api.fork_rule, rule_id, _strip_none(payload))
+
+    async def rule_export(self, rule_id: str, format: str) -> str:
+        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",