agenticwerx-mcp-client 1.0.0__py3-none-any.whl → 1.0.5__py3-none-any.whl

agenticwerx_mcp_client/client.py

@@ -7,172 +7,381 @@ AgenticWerx MCP server to retrieve rules.
 
 import json
 import logging
-from typing import Any, Dict, List
+from typing import Any
 
 from mcp.server import Server
-from mcp.types import Resource, Tool, TextContent
 from mcp.server.models import InitializationOptions
+from mcp.types import Resource, TextContent, Tool
 
 from .api import AgenticWerxAPI, AgenticWerxAPIError
 
-
 logger = logging.getLogger(__name__)
 
 
 class AgenticWerxMCPClient:
     """
     Simple AgenticWerx MCP Client for rule retrieval.
-    
+
     This client connects to your AgenticWerx MCP server and provides
     a simple interface to get rules through the MCP protocol.
     """
-    
+
     def __init__(self, api_key: str, debug: bool = False):
         """
         Initialize the MCP client.
-        
+
         Args:
             api_key: AgenticWerx API key
             debug: Enable debug logging
         """
         self.api_key = api_key
         self.debug = debug
-        
+
         # Initialize the API client
         self.api = AgenticWerxAPI(api_key)
-        
+
         # Initialize the MCP server
         self.server = Server("agenticwerx")
-        
+
         # Configure logging
         if debug:
             logging.getLogger().setLevel(logging.DEBUG)
-        
+
         logger.info("Initializing AgenticWerx MCP Client")
-        
+
         # Set up MCP handlers
         self._setup_handlers()
-    
+
     def _setup_handlers(self) -> None:
         """Set up MCP server handlers."""
-        
+
         @self.server.list_resources()
-        async def list_resources() -> List[Resource]:
+        async def list_resources() -> list[Resource]:
             """List available rule resources."""
             logger.debug("Listing available rule resources")
-            
+
             try:
                 # Test if we can get rules from the Lambda MCP server
-                rules_data = await self.api.get_rules()
-                
+                await self.api.get_rules()
+
                 # Create a single resource for all rules
                 resource = Resource(
                     uri="agenticwerx://rules",
                     name="AgenticWerx Rules",
                     description="All available AgenticWerx rules from Lambda MCP server",
-                    mimeType="application/json"
+                    mimeType="application/json",
                 )
-                
+
                 logger.info("Listed rule resources from Lambda MCP server")
                 return [resource]
-                
+
             except AgenticWerxAPIError as e:
                 logger.error(f"API error listing resources: {e}")
                 return []
             except Exception as e:
                 logger.error(f"Unexpected error listing resources: {e}")
                 return []
-        
+
         @self.server.read_resource()
         async def read_resource(uri: str) -> str:
             """Read rule resource."""
             logger.debug(f"Reading resource: {uri}")
-            
+
             if uri != "agenticwerx://rules":
                 raise ValueError(f"Unknown resource URI: {uri}")
-            
+
             try:
                 rules_data = await self.api.get_rules()
                 logger.debug("Successfully read rules resource from Lambda MCP server")
                 return json.dumps(rules_data, indent=2)
-                
+
             except AgenticWerxAPIError as e:
                 logger.error(f"API error reading resource: {e}")
                 raise
             except Exception as e:
                 logger.error(f"Unexpected error reading resource: {e}")
-                raise ValueError(f"Failed to read resource: {str(e)}")
-        
+                raise ValueError(f"Failed to read resource: {str(e)}") from e
+
         @self.server.list_tools()
-        async def list_tools() -> List[Tool]:
+        async def list_tools() -> list[Tool]:
             """List available tools."""
             logger.debug("Listing available tools")
-            
-            # Only provide the analyze tool (which calls get_rules internally)
+
+            # Provide get_rules and analyze_code tools
             tools = [
                 Tool(
-                    name="analyze",
-                    description="Analyze code using AgenticWerx rules. Optionally specify a packageId to use rules from a specific package.",
+                    name="get_rules",
+                    description=(
+                        "Get available rules for subscribed packages.\n\n"
+                        "📋 Response Modes:\n"
+                        "  • Summary (default): Just id, title, category, severity\n"
+                        "  • Detailed (detailed=true): Includes instructions, rationale, tags, references\n"
+                        "  • With Content (includeContent=true): Full markdown/JSON content\n"
+                        "  • With Patterns (includePatterns=true + detailed=true): Regex patterns\n\n"
+                        "💡 Tip: Start with summary mode, then use detailed=true or includeContent=true "
+                        "when you need more information about specific rules."
+                    ),
                     inputSchema={
                         "type": "object",
                         "properties": {
                             "packageId": {
                                 "type": "string",
-                                "description": "Optional package ID to use rules from a specific package"
-                            }
+                                "description": "Specific package ID (optional)",
+                            },
+                            "language": {
+                                "type": "string",
+                                "description": "Filter by programming language (e.g., typescript, python, go)",
+                            },
+                            "framework": {
+                                "type": "string",
+                                "description": "Filter by framework (e.g., react, nextjs, express)",
+                            },
+                            "category": {
+                                "type": "string",
+                                "description": "Filter by category (e.g., security, api-design, testing)",
+                            },
+                            "severity": {
+                                "type": "string",
+                                "description": "Filter by severity (critical, high, medium, low)",
+                            },
+                            "appliesTo": {
+                                "type": "string",
+                                "description": "Filter by applies to (e.g., frontend, backend, api, all)",
+                            },
+                            "search": {
+                                "type": "string",
+                                "description": "Search in rule titles and descriptions",
+                            },
+                            "ruleIds": {
+                                "type": "array",
+                                "items": {"type": "string"},
+                                "description": "Get specific rules by ID",
+                            },
+                            "detailed": {
+                                "type": "boolean",
+                                "description": "⭐ Get full rule details (instructions, rationale, tags). Default: false",
+                            },
+                            "includeContent": {
+                                "type": "boolean",
+                                "description": "⭐ Get complete rule content (markdown/JSON). Warning: Large responses. Default: false",
+                            },
+                            "includePatterns": {
+                                "type": "boolean",
+                                "description": "⭐ Include regex patterns (requires detailed=true). Default: false",
+                            },
+                            "limit": {
+                                "type": "number",
+                                "description": "Maximum rules to return (1-200). Default: 50",
+                            },
+                            "offset": {
+                                "type": "number",
+                                "description": "Skip N rules for pagination. Default: 0",
+                            },
                         },
-                        "additionalProperties": False
-                    }
-                )
+                        "additionalProperties": False,
+                    },
+                ),
+                Tool(
+                    name="analyze_code",
+                    description="Analyze code using AgenticWerx rules. Provide code snippet, optional language, and optional package IDs.",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "code": {
+                                "type": "string",
+                                "description": "Code to analyze",
+                            },
+                            "language": {
+                                "type": "string",
+                                "description": "Programming language (optional, will be auto-detected)",
+                            },
+                            "packageIds": {
+                                "type": "array",
+                                "items": {"type": "string"},
+                                "description": "List of package IDs to use for analysis (optional)",
+                            },
+                        },
+                        "required": ["code"],
+                        "additionalProperties": False,
+                    },
+                ),
             ]
-            
-            logger.info(f"Listed {len(tools)} available tools (analyze only)")
+
+            logger.info(f"Listed {len(tools)} available tools")
             return tools
-        
+
         @self.server.call_tool()
-        async def call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
+        async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
             """Execute a tool."""
             logger.debug(f"Executing tool: {name}")
-            
+
             try:
-                if name == "analyze":
-                    # Handle analyze tool - internally calls get_rules
-                    package_id = arguments.get("packageId") or arguments.get("package_id")
-                    result = await self.api.get_rules(package_id)
-                    
+                if name == "get_rules":
+                    # Handle get_rules tool with enhanced parameters
+                    detailed = arguments.get("detailed", False)
+                    include_content = arguments.get("includeContent", False)
+                    include_patterns = arguments.get("includePatterns", False)
+
+                    # Build params dict with all parameters
+                    params = {
+                        "packageId": arguments.get("packageId"),
+                        "language": arguments.get("language"),
+                        "framework": arguments.get("framework"),
+                        "category": arguments.get("category"),
+                        "severity": arguments.get("severity"),
+                        "appliesTo": arguments.get("appliesTo"),
+                        "search": arguments.get("search"),
+                        "ruleIds": arguments.get("ruleIds"),
+                        "limit": arguments.get("limit", 50),
+                        "offset": arguments.get("offset", 0),
+                        "detailed": detailed,
+                        "includePatterns": include_patterns,
+                        "includeContent": include_content,
+                    }
+
+                    # Remove None values
+                    params = {k: v for k, v in params.items() if v is not None}
+
+                    # Call the API with all parameters
+                    result = await self.api.call_tool("get_rules", params)
+
+                    # Parse the response - Lambda returns content array
+                    content = result.get("content", [])
+
+                    # Extract message and rules data from content array
+                    message_text = ""
+                    rules_data = None
+
+                    for item in content:
+                        if item.get("type") == "text":
+                            text = item.get("text", "")
+                            # Try to parse as JSON (second content item)
+                            try:
+                                parsed = json.loads(text)
+                                if "rules" in parsed and "summary" in parsed:
+                                    rules_data = parsed
+                            except json.JSONDecodeError:
+                                # First content item - the message from Lambda
+                                message_text = text
+
+                    # If no rules data found, return just the message
+                    if not rules_data:
+                        return [
+                            TextContent(
+                                type="text",
+                                text=message_text or "No rules found",
+                            )
+                        ]
+
+                    # Extract summary for hints
+                    summary = rules_data.get("summary", {})
+                    has_more = summary.get("hasMore", False)
+                    offset = summary.get("offset", 0)
+                    limit = summary.get("limit", 50)
+
+                    # Build response with contextual hints
+                    response_parts = [message_text]
+
+                    # Add contextual hints based on current mode
+                    if not detailed and not include_content:
+                        response_parts.append(
+                            "\n\n💡 Tip: You're viewing summary mode (minimal info). "
+                            "To get more details, use:\n"
+                            "  • detailed=true - Get full rule details (instructions, rationale, tags)\n"
+                            "  • includeContent=true - Get complete rule content (markdown/JSON)\n"
+                            "  • includePatterns=true - Get regex patterns (requires detailed=true)"
+                        )
+                    elif detailed and not include_content:
+                        response_parts.append(
+                            "\n\n💡 Tip: Use includeContent=true to get the full rule content (markdown/JSON)"
+                        )
+
+                    # Add pagination hint if there are more results
+                    if has_more:
+                        next_offset = offset + limit
+                        response_parts.append(
+                            f"\n\n📄 More results available. Use offset={next_offset} to get the next page."
+                        )
+
+                    # Build final response
+                    response_text = "".join(response_parts)
+
+                    logger.debug("Successfully retrieved rules")
+                    return [
+                        TextContent(type="text", text=response_text),
+                        TextContent(
+                            type="text", text=json.dumps(rules_data, indent=2)
+                        ),
+                    ]
+
+                elif name == "analyze_code":
+                    # Handle analyze_code tool
+                    code = arguments.get("code")
+                    if not code:
+                        error_msg = "Missing required parameter: code"
+                        logger.warning(error_msg)
+                        return [
+                            TextContent(
+                                type="text",
+                                text=json.dumps({"error": error_msg}, indent=2),
+                            )
+                        ]
+
+                    language = arguments.get("language")
+                    package_ids = arguments.get("packageIds") or arguments.get(
+                        "package_ids"
+                    )
+
+                    result = await self.api.analyze_code(code, language, package_ids)
+
                     response = {
-                        "tool": "analyze",
-                        "packageId": package_id,
-                        "rules": result
+                        "tool": "analyze_code",
+                        "language": language,
+                        "packageIds": package_ids,
+                        "analysis": result,
                     }
-                    
-                    logger.debug("Successfully retrieved rules for analysis")
-                    return [TextContent(type="text", text=json.dumps(response, indent=2))]
-                
+
+                    logger.debug("Successfully analyzed code")
+                    return [
+                        TextContent(type="text", text=json.dumps(response, indent=2))
+                    ]
+
                 else:
-                    # Only analyze tool is supported
-                    error_msg = f"Tool '{name}' is not supported. Only 'analyze' tool is available."
+                    # Unsupported tool
+                    error_msg = f"Tool '{name}' is not supported. Available tools: get_rules, analyze_code"
                     logger.warning(f"Unsupported tool requested: {name}")
-                    return [TextContent(type="text", text=json.dumps({"error": error_msg}, indent=2))]
-                
+                    return [
+                        TextContent(
+                            type="text", text=json.dumps({"error": error_msg}, indent=2)
+                        )
+                    ]
+
             except AgenticWerxAPIError as e:
                 error_msg = f"AgenticWerx API Error: {str(e)}"
                 logger.error(f"API error in tool {name}: {e}")
-                return [TextContent(type="text", text=json.dumps({"error": error_msg}, indent=2))]
-            
+                return [
+                    TextContent(
+                        type="text", text=json.dumps({"error": error_msg}, indent=2)
+                    )
+                ]
+
             except Exception as e:
                 error_msg = f"Tool execution error: {str(e)}"
                 logger.error(f"Unexpected error in tool {name}: {e}")
-                return [TextContent(type="text", text=json.dumps({"error": error_msg}, indent=2))]
-    
+                return [
+                    TextContent(
+                        type="text", text=json.dumps({"error": error_msg}, indent=2)
+                    )
+                ]
+
     async def test_connection(self) -> bool:
         """Test connection to the Lambda MCP server."""
         return await self.api.test_connection()
-    
+
     async def run(self) -> None:
         """Run the MCP server."""
         logger.info("Starting AgenticWerx MCP Client")
-        
+
         # Test connection to Lambda MCP server on startup
         logger.info("Testing connection to Lambda MCP server...")
         connection_ok = await self.test_connection()
@@ -181,41 +390,43 @@ class AgenticWerxMCPClient:
             # Continue anyway - the client might still work for some operations
         else:
             logger.info("Successfully connected to Lambda MCP server")
-        
+
         try:
             from mcp.server.stdio import stdio_server
-            
+
             async with stdio_server() as (read_stream, write_stream):
                 logger.info("MCP Client started, waiting for connections...")
-                
-                from mcp.types import ServerCapabilities, ResourcesCapability, ToolsCapability
-                
+
+                from mcp.types import (
+                    ResourcesCapability,
+                    ServerCapabilities,
+                    ToolsCapability,
+                )
+
                 init_options = InitializationOptions(
                     server_name="agenticwerx",
                     server_version="1.0.0",
                     capabilities=ServerCapabilities(
-                        resources=ResourcesCapability(subscribe=False, listChanged=False),
-                        tools=ToolsCapability(listChanged=False)
-                    )
-                )
-                
-                await self.server.run(
-                    read_stream,
-                    write_stream,
-                    init_options
+                        resources=ResourcesCapability(
+                            subscribe=False, listChanged=False
+                        ),
+                        tools=ToolsCapability(listChanged=False),
+                    ),
                 )
-                
+
+                await self.server.run(read_stream, write_stream, init_options)
+
         except Exception as e:
             logger.error(f"Error running MCP server: {e}")
             raise
         finally:
             await self.api.close()
             logger.info("AgenticWerx MCP Client stopped")
-    
+
     async def __aenter__(self):
         """Async context manager entry."""
         return self
-    
+
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Async context manager exit."""
-        await self.api.close()
+        await self.api.close()

{agenticwerx_mcp_client-1.0.0.dist-info → agenticwerx_mcp_client-1.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenticwerx-mcp-client
-Version: 1.0.0
+Version: 1.0.5
 Summary: Simple MCP client that connects to your AgenticWerx MCP server to retrieve rules
 Project-URL: Homepage, https://agenticwerx.com
 Project-URL: Documentation, https://docs.agenticwerx.com/mcp-client
@@ -14,14 +14,13 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Quality Assurance
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Requires-Dist: httpx>=0.25.0
 Requires-Dist: mcp>=1.0.0
 Requires-Dist: pydantic>=2.0.0
@@ -55,7 +54,31 @@ A Model Context Protocol (MCP) client that connects to the AgenticWerx Lambda MC
 
 ## 🚀 Quick Start
 
-### For IDE Users
+The AgenticWerx MCP Client supports two modes:
+
+### CLI Mode - Direct Command Line Usage
+
+```bash
+# Get rules
+uvx agenticwerx-mcp-client@latest --api-key YOUR_KEY get-rules
+
+# Analyze code
+uvx agenticwerx-mcp-client@latest --api-key YOUR_KEY analyze-code --file script.py
+
+# Analyze code snippet
+uvx agenticwerx-mcp-client@latest --api-key YOUR_KEY analyze-code \
+  --code "print('hello')" --language python
+```
+
+**Features:**
+- 🔍 Auto-detects programming language from file extensions
+- 📦 Automatically chunks large files (>8KB) for analysis
+- 📊 Aggregates results from multiple chunks
+- 🎯 Supports 20+ programming languages
+
+See [CLI_USAGE.md](CLI_USAGE.md) for detailed CLI documentation.
+
+### MCP Server Mode - For IDE Integration
 
 Add this configuration to your MCP-compatible IDE (Kiro, Amazon Q Developer, etc.):
 
@@ -64,7 +87,7 @@ Add this configuration to your MCP-compatible IDE (Kiro, Amazon Q Developer, etc
   "mcpServers": {
     "agenticwerx": {
       "command": "uvx",
-      "args": ["agenticwerx-mcp-client@latest", "--api-key", "${AGENTICWERX_API_KEY}"],
+      "args": ["agenticwerx-mcp-client@latest"],
       "env": {
         "AGENTICWERX_API_KEY": "your-api-key-here"
       }
@@ -78,23 +101,33 @@ Add this configuration to your MCP-compatible IDE (Kiro, Amazon Q Developer, etc
 1. Visit [AgenticWerx Dashboard](https://agenticwerx.com/dashboard)
 2. Navigate to API Keys section
 3. Create a new API key
-4. Copy the key to your MCP configuration
+4. Use it in CLI or MCP configuration
 
 ## 🛠️ Available Tools
 
-The AgenticWerx MCP client provides a simple tool for code analysis:
+### MCP Server Mode Tools
+
+### **get_rules**
+Get AgenticWerx rules from the server.
 
-### **analyze**
+**Parameters:**
+- `packageId` (optional): Specific package ID to filter rules
+
+### **analyze_code**
 Analyze code using AgenticWerx rules from the server.
 
 **Parameters:**
-- `packageId` (optional): Specific package ID to use rules from a specific package
+- `code` (required): Code snippet to analyze
+- `language` (optional): Programming language
+- `packageIds` (optional): Array of package IDs to use for analysis
 
 **Example:**
 ```json
 {
-  "tool": "analyze",
-  "packageId": "stripe-integration-excellence-pack"
+  "tool": "analyze_code",
+  "code": "print('hello world')",
+  "language": "python",
+  "packageIds": ["stripe-integration-excellence-pack"]
 }
 ```
 

agenticwerx_mcp_client-1.0.5.dist-info/RECORD

@@ -0,0 +1,9 @@
+agenticwerx_mcp_client/__init__.py,sha256=cBAynWLhjKiLR4v44v1t0CSWtUGpGeqHjG8snleuN38,393
+agenticwerx_mcp_client/__main__.py,sha256=sixRKAe-yjlfq6siYxArGs5MqLn7wXHFOGFwG3aE6mg,11838
+agenticwerx_mcp_client/api.py,sha256=wapGF6LyTGCNE-3PRcEVljPigBNwJMFITxmMGHCEwCU,11025
+agenticwerx_mcp_client/client.py,sha256=qD28gj4pBtHvV-tkCSYBij2i6dYixQqHIR6tsMIygUc,18501
+agenticwerx_mcp_client-1.0.5.dist-info/METADATA,sha256=Q6Gc0i71ke8Jn0GFTXe7xcyLA38Tte-B7igCNofmX2Y,8697
+agenticwerx_mcp_client-1.0.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+agenticwerx_mcp_client-1.0.5.dist-info/entry_points.txt,sha256=JZ_xQZG_DpeObI-W0Kkl_xJyuuWyDvp4nvvNEoTBnSo,80
+agenticwerx_mcp_client-1.0.5.dist-info/licenses/LICENSE,sha256=q2BReOYGJ-oS4jzVbLIsPVDk1Gxw89w3EvFxTKEBfNk,1067
+agenticwerx_mcp_client-1.0.5.dist-info/RECORD,,

agenticwerx_mcp_client-1.0.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-agenticwerx_mcp_client/__init__.py,sha256=gNU_Q5Vxp_VnsKaq7YuHI4hYQ2k-o-3O2aZV6tQqNVU,392
-agenticwerx_mcp_client/__main__.py,sha256=zo38csH7kS-iEP1v3DrOIoY2y_h9-3RHG_g-JqQNcTc,3564
-agenticwerx_mcp_client/api.py,sha256=y14uWFFzu_YxPAu7UcuqQKCnNdzRJR5nN8KHmUKykTc,8547
-agenticwerx_mcp_client/client.py,sha256=k8_1pblBqHi9B83A3xF7okfxnX0DTPy8WIpXlCkeQHs,8572
-agenticwerx_mcp_client-1.0.0.dist-info/METADATA,sha256=iVy-vf-EkDY7wgmAk19lOB4fWf5A02LORyEr0Bpy0BI,7819
-agenticwerx_mcp_client-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-agenticwerx_mcp_client-1.0.0.dist-info/entry_points.txt,sha256=JZ_xQZG_DpeObI-W0Kkl_xJyuuWyDvp4nvvNEoTBnSo,80
-agenticwerx_mcp_client-1.0.0.dist-info/licenses/LICENSE,sha256=q2BReOYGJ-oS4jzVbLIsPVDk1Gxw89w3EvFxTKEBfNk,1067
-agenticwerx_mcp_client-1.0.0.dist-info/RECORD,,