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

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,129 +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 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 consolidate_memories(self, payload: Mapping[str, Any]) -> Any:
-        return self._request(
-            "POST", "/api/memory-intelligence/consolidate", json=payload
-        )
-
-    def smart_create_memory(self, payload: Mapping[str, Any]) -> Any:
-        return self._request(
-            "POST", "/api/memory-intelligence/smart-create", json=payload
-        )
-
-    # ------------------------------------------------------------------
-    # Configuration: modes and rules
-    # ------------------------------------------------------------------
-
-    def list_modes(
-        self,
-        *,
-        include_rules: Optional[bool] = None,
-        return_description: Optional[bool] = None,
-        return_metadata: Optional[bool] = None,
-    ) -> Any:
-        params = self._build_params(
-            optional={
-                "includeRules": include_rules,
-                "returnDescription": return_description,
-                "returnMetadata": return_metadata,
-            }
-        )
-        return self._request("GET", "/api/modes", params=params)
-
-    def get_mode(
-        self,
-        mode_id: str,
-        *,
-        return_description: Optional[bool] = None,
-        return_metadata: Optional[bool] = None,
-    ) -> Any:
-        params = self._build_params(
-            optional={
-                "returnDescription": return_description,
-                "returnMetadata": return_metadata,
-            }
-        )
-        return self._request("GET", f"/api/modes/{mode_id}", params=params)
-
-    def create_mode(self, payload: Mapping[str, Any]) -> Any:
-        return self._request("POST", "/api/modes", json=payload)
-
-    def update_mode(self, mode_id: str, payload: Mapping[str, Any]) -> Any:
-        return self._request("PATCH", f"/api/modes/{mode_id}", json=payload)
-
-    def delete_mode(self, mode_id: str) -> Any:
-        return self._request("DELETE", f"/api/modes/{mode_id}")
-
-    def list_rules(
-        self,
-        *,
-        return_description: Optional[bool] = None,
-        return_metadata: Optional[bool] = None,
-        return_modes: Optional[bool] = None,
-    ) -> Any:
-        params = self._build_params(
-            optional={
-                "returnDescription": return_description,
-                "returnMetadata": return_metadata,
-                "returnModes": return_modes,
-            }
-        )
-        return self._request("GET", "/api/rules", params=params)
-
-    def get_rule(
-        self,
-        rule_id: str,
-        *,
-        return_description: Optional[bool] = None,
-        return_metadata: Optional[bool] = None,
-        return_modes: Optional[bool] = None,
-    ) -> Any:
-        params = self._build_params(
-            optional={
-                "returnDescription": return_description,
-                "returnMetadata": return_metadata,
-                "returnModes": return_modes,
-            }
-        )
-        return self._request("GET", f"/api/rules/{rule_id}", params=params)
-
-    def create_rule(self, payload: Mapping[str, Any]) -> Any:
-        return self._request("POST", "/api/rules", json=payload)
-
-    def update_rule(self, rule_id: str, payload: Mapping[str, Any]) -> Any:
-        return self._request("PATCH", f"/api/rules/{rule_id}", json=payload)
-
-    def delete_rule(self, rule_id: str) -> Any:
-        return self._request("DELETE", f"/api/rules/{rule_id}")
-
-    def add_mode_rule(self, mode_id: str, rule_id: str) -> Any:
-        payload = {"modeId": mode_id, "ruleId": rule_id}
-        return self._request("POST", "/api/mode-rules", json=payload)
-
-    def remove_mode_rule(self, mode_id: str, rule_id: str) -> Any:
-        return self._request("DELETE", f"/api/mode-rules/mode/{mode_id}/rule/{rule_id}")
-
-    def list_rules_by_mode(self, mode_id: str) -> Any:
-        return self._request("GET", f"/api/mode-rules/mode/{mode_id}/rules")
-
-    def list_modes_by_rule(self, rule_id: str) -> Any:
-        return self._request("GET", f"/api/mode-rules/rule/{rule_id}/modes")
+    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
@@ -691,3 +575,155 @@ class FenixApiClient:
 
     def cancel_sprint(self, sprint_id: str) -> Any:
         return self._request("PATCH", f"/api/sprints/{sprint_id}/cancel")
+
+    # ------------------------------------------------------------------
+    # Rules
+    # ------------------------------------------------------------------
+
+    def create_rule(self, payload: Mapping[str, Any]) -> Any:
+        return self._request("POST", "/api/rules", json=payload)
+
+    def list_rules(self, **filters: Any) -> Any:
+        return self._request("GET", "/api/rules", params=_strip_none(filters))
+
+    def get_rule(self, rule_id: str) -> Any:
+        return self._request("GET", f"/api/rules/{rule_id}")
+
+    def update_rule(self, rule_id: str, payload: Mapping[str, Any]) -> Any:
+        return self._request("PATCH", f"/api/rules/{rule_id}", json=payload)
+
+    def delete_rule(self, rule_id: str) -> Any:
+        return self._request("DELETE", f"/api/rules/{rule_id}")
+
+    def list_marketplace_rules(self, **filters: Any) -> Any:
+        return self._request(
+            "GET", "/api/rules/marketplace/list", params=_strip_none(filters)
+        )
+
+    def search_marketplace_rules(self, *, query: str, limit: int = 20) -> Any:
+        params = self._build_params(required={"q": query}, optional={"limit": limit})
+        return self._request("GET", "/api/rules/marketplace/search", params=params)
+
+    def get_top_marketplace_rules(self, *, limit: int = 10) -> Any:
+        params = self._build_params(optional={"limit": limit})
+        return self._request("GET", "/api/rules/marketplace/top", params=params)
+
+    def fork_rule(self, rule_id: str, payload: Mapping[str, Any]) -> Any:
+        return self._request("POST", f"/api/rules/{rule_id}/fork", json=payload)
+
+    def download_rule(self, rule_id: str) -> Any:
+        return self._request("POST", f"/api/rules/{rule_id}/download")
+
+    def rate_rule(self, rule_id: str, rating: float) -> Any:
+        return self._request(
+            "POST", f"/api/rules/{rule_id}/rate", json={"rating": rating}
+        )
+
+    def export_rule(self, rule_id: str, format: str) -> Any:
+        return self._request("GET", f"/api/rules/{rule_id}/export/{format}")
+
+    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}")
 
 

fenix_mcp-2.0.0.dist-info/METADATA

@@ -0,0 +1,341 @@
+Metadata-Version: 2.4
+Name: fenix-mcp
+Version: 2.0.0
+Summary: Fênix Cloud MCP server implemented in Python
+Author: Fenix Inc
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.5
+Requires-Dist: requests>=2.31
+Requires-Dist: urllib3>=2.0
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: pydantic-settings>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: flake8>=6.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+
+<p align="center">
+  <img src="https://fenix.devshire.app/logos/logo_fenix.png" alt="Fenix MCP" width="200" />
+</p>
+
+<p align="center">
+  <strong>Fenix MCP Server</strong><br/>
+  Python MCP server for Fenix Cloud API integration
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/fenix-mcp/"><img src="https://img.shields.io/pypi/v/fenix-mcp.svg" alt="PyPI"></a>
+  <a href="https://www.python.org/"><img src="https://img.shields.io/badge/python-3.10%2B-blue.svg" alt="Python"></a>
+  <a href="./LICENSE"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License"></a>
+</p>
+
+<p align="center">
+  <a href="#quick-start">Quick Start</a> •
+  <a href="#installation">Installation</a> •
+  <a href="#configuration">Configuration</a> •
+  <a href="#project-structure">Structure</a>
+</p>
+
+---
+
+## Overview
+
+Fenix MCP connects MCP-compatible clients (Claude Code, Cursor, Windsurf, VS Code, etc.) directly to the Fenix Cloud APIs. Every tool invocation hits the live backend—no outdated snapshots or hallucinated IDs.
+
+**Available Tools:**
+- `knowledge` — Documentation CRUD, work items, modes, rules
+- `productivity` — TODO management
+- `intelligence` — Memories and smart operations
+- `user_config` — User configuration documents
+- `initialize` — Personalized setup
+- `health` — Backend health check
+
+---
+
+## Quick Start
+
+```bash
+pipx install fenix-mcp                    # Install
+fenix-mcp --pat <your-token>              # Run (STDIO mode)
+```
+
+---
+
+## Requirements
+
+| Requirement | Version |
+|-------------|---------|
+| Python | 3.10+ |
+| Fenix PAT Token | Required |
+| MCP Client | Claude Code, Cursor, Windsurf, VS Code, etc. |
+
+---
+
+## Installation
+
+### With pipx (recommended)
+
+```bash
+pipx install fenix-mcp
+```
+
+### With pip
+
+```bash
+pip install --user fenix-mcp
+```
+
+### Upgrade
+
+```bash
+pipx upgrade fenix-mcp
+# or
+pip install --upgrade fenix-mcp
+```
+
+---
+
+## Configuration
+
+### MCP Client Setup
+
+<details>
+<summary><strong>Claude Code</strong> — ~/.claude/config.toml</summary>
+
+```toml
+[mcp_servers.fenix]
+command = "fenix-mcp"
+args = ["--pat", "your-token"]
+```
+
+</details>
+
+<details>
+<summary><strong>Cursor</strong> — ~/.cursor/mcp.json</summary>
+
+```json
+{
+  "mcpServers": {
+    "fenix": {
+      "command": "fenix-mcp",
+      "args": ["--pat", "your-token"],
+      "disabled": false
+    }
+  }
+}
+```
+
+</details>
+
+<details>
+<summary><strong>VS Code / Windsurf</strong> — settings.json</summary>
+
+```json
+{
+  "modelContextProtocol.mcpServers": {
+    "fenix": {
+      "command": "fenix-mcp",
+      "args": ["--pat", "your-token"]
+    }
+  }
+}
+```
+
+</details>
+
+---
+
+<details>
+<summary><strong>Environment Variables</strong></summary>
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `FENIX_API_URL` | Fenix Cloud API base URL | `https://fenix-api.devshire.app` |
+| `FENIX_PAT_TOKEN` | Token (alternative to `--pat`) | empty |
+| `FENIX_TRANSPORT_MODE` | `stdio`, `http`, or `both` | `stdio` |
+| `FENIX_HTTP_HOST` | HTTP transport host | `127.0.0.1` |
+| `FENIX_HTTP_PORT` | HTTP transport port | `5003` |
+| `FENIX_LOG_LEVEL` | Log level (`DEBUG`, `INFO`, etc.) | `INFO` |
+
+See [`.env.example`](./.env.example) for reference.
+
+</details>
+
+<details>
+<summary><strong>HTTP Transport</strong></summary>
+
+```bash
+export FENIX_TRANSPORT_MODE=http
+export FENIX_HTTP_PORT=5003
+fenix-mcp --pat <your-token>
+```
+
+JSON-RPC endpoint: `http://127.0.0.1:5003/jsonrpc`
+
+Run both STDIO and HTTP:
+
+```bash
+export FENIX_TRANSPORT_MODE=both
+fenix-mcp --pat <your-token>
+```
+
+</details>
+
+---
+
+## Project Structure
+
+```
+fenix-mcp-py/
+├── fenix_mcp/                  # Main package
+│   ├── main.py                 # Entry point (CLI)
+│   ├── application/            # Use cases and services
+│   ├── domain/                 # Business entities
+│   ├── infrastructure/         # External integrations (API, transport)
+│   └── interface/              # MCP protocol handlers
+├── tests/                      # Test suite
+├── docs/                       # Documentation
+├── pyproject.toml              # Project configuration
+└── .env.example                # Environment template
+```
+
+<details>
+<summary><strong>fenix_mcp/</strong> — Package Structure</summary>
+
+| Directory | Responsibility |
+|-----------|----------------|
+| `main.py` | CLI entry point, argument parsing, server bootstrap |
+| `application/` | Use cases, handlers for each MCP tool |
+| `domain/` | Business entities, DTOs, validation |
+| `infrastructure/` | API client, HTTP transport, logging |
+| `interface/` | MCP protocol implementation, tool registration |
+
+### Architecture
+
+```
+MCP Client → interface/ → application/ → infrastructure/ → Fenix API
+                              ↓
+                          domain/
+                        (entities)
+```
+
+</details>
+
+---
+
+## Tech Stack
+
+| Layer | Technology |
+|-------|------------|
+| Runtime | Python 3.10+ |
+| Validation | Pydantic 2 |
+| HTTP | aiohttp, requests |
+| Config | pydantic-settings |
+| Testing | pytest, pytest-asyncio |
+| Linting | flake8, black, mypy |
+
+---
+
+## Development
+
+### Setup
+
+```bash
+# Clone and install
+git clone <repo>
+cd fenix-mcp-py
+pip install -e .[dev]
+```
+
+### Scripts
+
+| Command | Description |
+|---------|-------------|
+| `pytest` | Run tests |
+| `pytest --cov=fenix_mcp` | Run with coverage |
+| `black fenix_mcp/ tests/` | Format code |
+| `flake8 fenix_mcp/ tests/` | Lint |
+| `mypy fenix_mcp/` | Type check |
+
+### Commit Convention
+
+Follow [Conventional Commits](https://www.conventionalcommits.org/):
+
+| Prefix | Description | Version Bump |
+|--------|-------------|--------------|
+| `fix:` | Bug fixes | Patch |
+| `feat:` | New features | Minor |
+| `BREAKING CHANGE:` | Breaking changes | Major |
+| `chore:` | Maintenance | None |
+| `docs:` | Documentation | None |
+
+---
+
+## CI/CD
+
+| Platform | Usage |
+|----------|-------|
+| GitHub Actions | Tests, lint, build on push/PR to main |
+| Semantic Release | Auto-version based on commits |
+| PyPI | Package distribution |
+
+---
+
+## Troubleshooting
+
+<details>
+<summary><code>command not found: fenix-mcp</code></summary>
+
+Add scripts directory to PATH:
+
+```bash
+# macOS/Linux
+export PATH="$PATH:~/.local/bin"
+
+# Windows
+# Add %APPDATA%\Python\Python311\Scripts to PATH
+```
+
+</details>
+
+<details>
+<summary><code>401 Unauthorized</code></summary>
+
+1. Check `--pat` or `FENIX_PAT_TOKEN` is set correctly
+2. Regenerate token in Fenix Cloud if expired
+
+</details>
+
+<details>
+<summary>Run HTTP and STDIO simultaneously</summary>
+
+```bash
+export FENIX_TRANSPORT_MODE=both
+fenix-mcp --pat <your-token>
+```
+
+</details>
+
+---
+
+## Security
+
+- Store tokens securely (keychain, `pass`, `.env`)
+- Never commit secrets to git
+- Revoke tokens when no longer needed
+- Use `pipx` to isolate from global Python
+
+---
+
+## Useful Links
+
+| Resource | URL |
+|----------|-----|
+| PyPI | https://pypi.org/project/fenix-mcp/ |
+| Fenix Cloud | https://fenix.devshire.app |
+| MCP Protocol | https://modelcontextprotocol.io |