fedramp-20x-mcp 0.4.8__py3-none-any.whl

fedramp_20x_mcp/tools/ksi.py

@@ -0,0 +1,90 @@
+"""
+FedRAMP 20x MCP Server - Ksi Tools
+
+This module contains tool implementation functions for ksi.
+"""
+import json
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+async def get_ksi_impl(ksi_id: str, data_loader) -> str:
+    """
+    Get detailed information about a specific Key Security Indicator.
+
+    Args:
+        ksi_id: The KSI identifier (e.g., "KSI-ALL-01")
+
+    Returns:
+        Detailed KSI information
+    """
+    try:
+        # Ensure data is loaded
+        await data_loader.load_data()
+        
+        # Get the KSI
+        ksi = data_loader.get_ksi(ksi_id)
+        
+        if not ksi:
+            return f"Key Security Indicator {ksi_id} not found. Use list_ksi() to see all available indicators."
+        
+        # Format the KSI information
+        result = f"# Key Security Indicator: {ksi.get('id', ksi_id)}\n\n"
+        
+        # Add all KSI fields
+        for key, value in ksi.items():
+            if key not in ["id", "document", "document_name", "section"]:
+                result += f"**{key.replace('_', ' ').title()}:**\n"
+                if isinstance(value, (dict, list)):
+                    result += f"```json\n{json.dumps(value, indent=2)}\n```\n\n"
+                else:
+                    result += f"{value}\n\n"
+        
+        # Add context
+        result += f"**Document:** {ksi.get('document_name', 'Unknown')}\n"
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error fetching KSI {ksi_id}: {e}")
+        return f"Error retrieving KSI {ksi_id}: {str(e)}"
+
+
+
+async def list_ksi_impl(data_loader) -> str:
+    """
+    List all Key Security Indicators.
+
+    Returns:
+        Complete list of all Key Security Indicators
+    """
+    try:
+        # Ensure data is loaded
+        await data_loader.load_data()
+        
+        # Get all KSI
+        ksi_list = data_loader.list_all_ksi()
+        
+        if not ksi_list:
+            return "No Key Security Indicators found in the data."
+        
+        # Sort by ID
+        sorted_ksi = sorted(ksi_list, key=lambda x: x.get("id", ""))
+        
+        # Format the results
+        result = f"# Key Security Indicators\n\n"
+        result += f"Total: {len(ksi_list)} indicators\n\n"
+        
+        for ksi in sorted_ksi:
+            ksi_id = ksi.get("id", "Unknown")
+            title = ksi.get("title", ksi.get("name", "No title"))
+            result += f"- **{ksi_id}**: {title}\n"
+        
+        result += "\n*Use get_ksi(ksi_id) to see full details for any indicator.*\n"
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error listing KSI: {e}")
+        return f"Error retrieving KSI: {str(e)}"

fedramp_20x_mcp/tools/requirements.py

@@ -0,0 +1,163 @@
+"""
+FedRAMP 20x MCP Server - Requirements Tools
+
+This module contains tool implementation functions for requirements.
+"""
+import json
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+async def get_control_impl(control_id: str, data_loader) -> str:
+    """
+    Get detailed information about a specific FedRAMP 20x requirement.
+
+    Args:
+        control_id: The requirement identifier (e.g., "FRD-ALL-01", "VDR-ALL-02")
+
+    Returns:
+        Detailed information about the requirement including definition,
+        notes, references, and related information
+    """
+    try:
+        # Ensure data is loaded
+        await data_loader.load_data()
+        
+        # Get the requirement
+        req = data_loader.get_control(control_id)
+        
+        if not req:
+            return f"Requirement {control_id} not found in FedRAMP 20x data."
+        
+        # Format the requirement information
+        result = f"# Requirement: {req.get('id', control_id)}\n\n"
+        
+        # Add term if present
+        if "term" in req:
+            result += f"## Term: {req['term']}\n\n"
+        
+        # Add definition
+        if "definition" in req:
+            result += f"**Definition:**\n{req['definition']}\n\n"
+        
+        # Add alternatives
+        if "alts" in req and req["alts"]:
+            result += f"**Also known as:** {', '.join(req['alts'])}\n\n"
+        
+        # Add notes
+        if "note" in req:
+            result += f"**Note:**\n{req['note']}\n\n"
+        elif "notes" in req and isinstance(req["notes"], list):
+            result += "**Notes:**\n"
+            for note in req["notes"]:
+                result += f"- {note}\n"
+            result += "\n"
+        
+        # Add references
+        if "reference" in req:
+            ref_url = req.get("reference_url", "")
+            if ref_url:
+                result += f"**Reference:** [{req['reference']}]({ref_url})\n\n"
+            else:
+                result += f"**Reference:** {req['reference']}\n\n"
+        
+        # Add document context
+        result += f"**Document:** {req.get('document_name', 'Unknown')}\n"
+        result += f"**Section:** {req.get('section', 'Unknown')}\n"
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error fetching requirement {control_id}: {e}")
+        return f"Error retrieving requirement {control_id}: {str(e)}"
+
+
+
+async def list_family_controls_impl(family: str, data_loader) -> str:
+    """
+    List all requirements within a specific document family.
+
+    Args:
+        family: The document family identifier (e.g., "FRD", "VDR", "CCM")
+
+    Returns:
+        List of all requirements in the specified family with brief descriptions
+    """
+    try:
+        # Ensure data is loaded
+        await data_loader.load_data()
+        
+        # Get family requirements
+        reqs = data_loader.get_family_controls(family)
+        
+        if not reqs:
+            return f"No requirements found for family {family}. Common families include: FRD (FedRAMP Definitions), VDR (Vulnerability Detection and Response), CCM (Collaborative Continuous Monitoring), etc."
+        
+        # Format the results
+        result = f"# Requirements in Family: {family.upper()}\n\n"
+        result += f"Found {len(reqs)} requirements:\n\n"
+        
+        for req in reqs:
+            req_id = req.get("id", "Unknown")
+            term = req.get("term", req.get("title", "No term"))
+            result += f"- **{req_id}**: {term}\n"
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error listing family {family}: {e}")
+        return f"Error retrieving family {family}: {str(e)}"
+
+
+
+async def search_requirements_impl(keywords: str, data_loader) -> str:
+    """
+    Search for FedRAMP 20x requirements containing specific keywords.
+
+    Args:
+        keywords: Keywords to search for in requirement text (space-separated)
+
+    Returns:
+        Matching requirements with IDs and relevant excerpts
+    """
+    try:
+        # Ensure data is loaded
+        await data_loader.load_data()
+        
+        # Search for requirements
+        reqs = data_loader.search_controls(keywords)
+        
+        if not reqs:
+            return f"No requirements found matching keywords: '{keywords}'"
+        
+        # Format the results
+        result = f"# Search Results for: '{keywords}'\n\n"
+        result += f"Found {len(reqs)} matching requirements:\n\n"
+        
+        # Limit to first 20 results to avoid overwhelming output
+        for req in reqs[:20]:
+            req_id = req.get("id", "Unknown")
+            term = req.get("term", "")
+            definition = req.get("definition", "")
+            
+            result += f"## {req_id}"
+            if term:
+                result += f": {term}"
+            result += "\n"
+            
+            # Show a snippet of the definition
+            if definition:
+                snippet = definition[:200] + "..." if len(definition) > 200 else definition
+                result += f"{snippet}\n\n"
+            else:
+                result += "Match found in requirement data.\n\n"
+        
+        if len(reqs) > 20:
+            result += f"\n*Showing first 20 of {len(reqs)} results. Refine your search for more specific results.*\n"
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error searching for '{keywords}': {e}")
+        return f"Error searching for '{keywords}': {str(e)}"