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

fedramp_20x_mcp/tools/__init__.py

@@ -0,0 +1,167 @@
+"""
+FedRAMP 20x MCP Server - Tools Module
+
+This module organizes all MCP tool functions into logical groups.
+Each submodule contains related tools that are registered with the MCP server.
+"""
+import json
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from mcp.server.fastmcp import FastMCP
+    from ..data_loader import FedRAMPDataLoader
+
+logger = logging.getLogger(__name__)
+
+
+def register_tools(mcp: "FastMCP", data_loader: "FedRAMPDataLoader"):
+    """
+    Register all tool functions with the MCP server.
+    
+    Args:
+        mcp: The FastMCP server instance
+        data_loader: The data loader instance for accessing FedRAMP data
+    """
+    # Import all tool modules
+    from . import requirements, definitions, ksi, documentation, export, enhancements, evidence
+    from ..templates import get_infrastructure_template, get_code_template
+    
+    # Requirements tools
+    @mcp.tool()
+    async def get_control(control_id: str) -> str:
+        """Get detailed information about a specific FedRAMP 20x requirement."""
+        return await requirements.get_control_impl(control_id, data_loader)
+    
+    @mcp.tool()
+    async def list_family_controls(family: str) -> str:
+        """List all requirements within a specific document family."""
+        return await requirements.list_family_controls_impl(family, data_loader)
+    
+    @mcp.tool()
+    async def search_requirements(keywords: str) -> str:
+        """Search for FedRAMP 20x requirements containing specific keywords."""
+        return await requirements.search_requirements_impl(keywords, data_loader)
+    
+    # Definition tools
+    @mcp.tool()
+    async def get_definition(term: str) -> str:
+        """Get the FedRAMP definition for a specific term."""
+        return await definitions.get_definition_impl(term, data_loader)
+    
+    @mcp.tool()
+    async def list_definitions() -> str:
+        """List all FedRAMP definitions with their terms."""
+        return await definitions.list_definitions_impl(data_loader)
+    
+    @mcp.tool()
+    async def search_definitions(keywords: str) -> str:
+        """Search FedRAMP definitions by keywords."""
+        return await definitions.search_definitions_impl(keywords, data_loader)
+    
+    # KSI tools
+    @mcp.tool()
+    async def get_ksi(ksi_id: str) -> str:
+        """Get detailed information about a specific Key Security Indicator."""
+        return await ksi.get_ksi_impl(ksi_id, data_loader)
+    
+    @mcp.tool()
+    async def list_ksi() -> str:
+        """List all Key Security Indicators."""
+        return await ksi.list_ksi_impl(data_loader)
+    
+    # Documentation tools
+    @mcp.tool()
+    async def search_documentation(keywords: str) -> str:
+        """Search FedRAMP official documentation by keywords."""
+        return await documentation.search_documentation_impl(keywords, data_loader)
+    
+    @mcp.tool()
+    async def get_documentation_file(file_path: str) -> str:
+        """Get the full content of a specific FedRAMP documentation file."""
+        return await documentation.get_documentation_file_impl(file_path, data_loader)
+    
+    @mcp.tool()
+    async def list_documentation_files() -> str:
+        """List all available FedRAMP documentation files."""
+        return await documentation.list_documentation_files_impl(data_loader)
+    
+    # Export tools
+    @mcp.tool()
+    async def export_to_excel(export_type: str, output_path: str = "") -> str:
+        """Export FedRAMP 20x data to Excel format."""
+        return await export.export_to_excel(export_type, output_path)
+    
+    @mcp.tool()
+    async def export_to_csv(export_type: str, output_path: str = "") -> str:
+        """Export FedRAMP 20x data to CSV format."""
+        return await export.export_to_csv(export_type, output_path)
+    
+    @mcp.tool()
+    async def generate_ksi_specification(ksi_id: str, evidence_collection_strategy: str, output_path: str = "") -> str:
+        """Generate a detailed product specification document for a KSI."""
+        return await export.generate_ksi_specification(ksi_id, evidence_collection_strategy, output_path)
+    
+    # Enhancement tools
+    @mcp.tool()
+    async def compare_with_rev4(requirement_area: str) -> str:
+        """Compare FedRAMP 20x requirements to Rev 4/Rev 5 to understand changes."""
+        return await enhancements.compare_with_rev4_impl(requirement_area, data_loader)
+    
+    @mcp.tool()
+    async def get_implementation_examples(requirement_id: str) -> str:
+        """Get practical implementation examples for a requirement."""
+        return await enhancements.get_implementation_examples_impl(requirement_id, data_loader)
+    
+    @mcp.tool()
+    async def check_requirement_dependencies(requirement_id: str) -> str:
+        """Show which requirements are related or dependent on a specific requirement."""
+        return await enhancements.check_requirement_dependencies_impl(requirement_id, data_loader)
+    
+    @mcp.tool()
+    async def estimate_implementation_effort(requirement_id: str) -> str:
+        """Provide rough effort estimates for implementing a specific requirement."""
+        return await enhancements.estimate_implementation_effort_impl(requirement_id, data_loader)
+    
+    @mcp.tool()
+    async def get_cloud_native_guidance(technology: str) -> str:
+        """Get cloud-native specific guidance for implementing FedRAMP 20x."""
+        return await enhancements.get_cloud_native_guidance_impl(technology, data_loader)
+    
+    @mcp.tool()
+    async def validate_architecture(architecture_description: str) -> str:
+        """Validate a cloud architecture against FedRAMP 20x requirements."""
+        return await enhancements.validate_architecture_impl(architecture_description, data_loader)
+    
+    @mcp.tool()
+    async def generate_implementation_questions(requirement_id: str) -> str:
+        """Generate strategic questions for PMs and engineers about implementing a requirement."""
+        return await enhancements.generate_implementation_questions_impl(requirement_id, data_loader)
+    
+    @mcp.tool()
+    async def get_ksi_implementation_matrix(ksi_family: str) -> str:
+        """Get implementation matrix showing all KSIs in a family with Azure services, effort, and priority."""
+        return await enhancements.get_ksi_implementation_matrix_impl(ksi_family, data_loader)
+    
+    @mcp.tool()
+    async def generate_implementation_checklist(ksi_id: str) -> str:
+        """Generate actionable step-by-step implementation checklist for a specific KSI."""
+        return await enhancements.generate_implementation_checklist_impl(ksi_id, data_loader)
+    
+    # Evidence automation tools
+    @mcp.tool()
+    async def get_infrastructure_code_for_ksi(ksi_id: str, infrastructure_type: str = "bicep") -> str:
+        """Generate infrastructure code templates for automating KSI evidence collection."""
+        return await evidence.get_infrastructure_code_for_ksi_impl(ksi_id, data_loader, get_infrastructure_template, infrastructure_type)
+    
+    @mcp.tool()
+    async def get_evidence_collection_code(ksi_id: str, language: str = "python") -> str:
+        """Provide code examples for collecting KSI evidence programmatically."""
+        return await evidence.get_evidence_collection_code_impl(ksi_id, data_loader, get_code_template, language)
+    
+    @mcp.tool()
+    async def get_evidence_automation_architecture(ksi_category: str = "all") -> str:
+        """Provide comprehensive architecture guidance for automated evidence collection."""
+        return await evidence.get_evidence_automation_architecture_impl(data_loader, ksi_category)
+    
+    logger.info("Registered 26 tools across 7 modules")

fedramp_20x_mcp/tools/definitions.py

@@ -0,0 +1,154 @@
+"""
+FedRAMP 20x MCP Server - Definitions Tools
+
+This module contains tool implementation functions for definitions.
+"""
+import json
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+async def get_definition_impl(term: str, data_loader) -> str:
+    """
+    Get the FedRAMP definition for a specific term.
+
+    Args:
+        term: The term to look up (e.g., "vulnerability", "agency", "cloud service offering")
+
+    Returns:
+        Definition with notes and references if available
+    """
+    try:
+        # Ensure data is loaded
+        await data_loader.load_data()
+        
+        # Get the definition
+        definition = data_loader.get_definition(term)
+        
+        if not definition:
+            return f"No FedRAMP definition found for term: '{term}'. Try searching with search_definitions() to find related terms."
+        
+        # Format the definition
+        result = f"# FedRAMP Definition: {definition.get('term', term)}\n\n"
+        
+        # Add ID
+        if "id" in definition:
+            result += f"**ID:** {definition['id']}\n\n"
+        
+        # Add definition
+        if "definition" in definition:
+            result += f"**Definition:**\n{definition['definition']}\n\n"
+        
+        # Add alternatives
+        if "alts" in definition and definition["alts"]:
+            result += f"**Also known as:** {', '.join(definition['alts'])}\n\n"
+        
+        # Add notes
+        if "note" in definition:
+            result += f"**Note:**\n{definition['note']}\n\n"
+        elif "notes" in definition and isinstance(definition["notes"], list):
+            result += "**Notes:**\n"
+            for note in definition["notes"]:
+                result += f"- {note}\n"
+            result += "\n"
+        
+        # Add references
+        if "reference" in definition:
+            ref_url = definition.get("reference_url", "")
+            if ref_url:
+                result += f"**Reference:** [{definition['reference']}]({ref_url})\n\n"
+            else:
+                result += f"**Reference:** {definition['reference']}\n\n"
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error fetching definition for '{term}': {e}")
+        return f"Error retrieving definition for '{term}': {str(e)}"
+
+
+
+async def list_definitions_impl(data_loader) -> str:
+    """
+    List all FedRAMP definitions with their terms.
+
+    Returns:
+        Complete list of FedRAMP definition terms
+    """
+    try:
+        # Ensure data is loaded
+        await data_loader.load_data()
+        
+        # Get all definitions
+        definitions = data_loader.list_all_definitions()
+        
+        if not definitions:
+            return "No FedRAMP definitions found."
+        
+        # Sort by ID
+        sorted_defs = sorted(definitions, key=lambda x: x.get("id", ""))
+        
+        # Format the results
+        result = f"# FedRAMP Definitions\n\n"
+        result += f"Total: {len(definitions)} definitions\n\n"
+        
+        for definition in sorted_defs:
+            def_id = definition.get("id", "Unknown")
+            term = definition.get("term", "No term")
+            result += f"- **{def_id}**: {term}\n"
+        
+        result += "\n*Use get_definition(term) to see full details for any term.*\n"
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error listing definitions: {e}")
+        return f"Error retrieving definitions: {str(e)}"
+
+
+
+async def search_definitions_impl(keywords: str, data_loader) -> str:
+    """
+    Search FedRAMP definitions by keywords.
+
+    Args:
+        keywords: Keywords to search for in definitions
+
+    Returns:
+        Matching definitions with terms and brief descriptions
+    """
+    try:
+        # Ensure data is loaded
+        await data_loader.load_data()
+        
+        # Search definitions
+        definitions = data_loader.search_definitions(keywords)
+        
+        if not definitions:
+            return f"No definitions found matching keywords: '{keywords}'"
+        
+        # Format the results
+        result = f"# Definition Search Results for: '{keywords}'\n\n"
+        result += f"Found {len(definitions)} matching definitions:\n\n"
+        
+        for definition in definitions[:20]:
+            def_id = definition.get("id", "Unknown")
+            term = definition.get("term", "No term")
+            def_text = definition.get("definition", "")
+            
+            result += f"## {def_id}: {term}\n"
+            
+            # Show a snippet
+            if def_text:
+                snippet = def_text[:150] + "..." if len(def_text) > 150 else def_text
+                result += f"{snippet}\n\n"
+        
+        if len(definitions) > 20:
+            result += f"\n*Showing first 20 of {len(definitions)} results.*\n"
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error searching definitions for '{keywords}': {e}")
+        return f"Error searching definitions for '{keywords}': {str(e)}"

fedramp_20x_mcp/tools/documentation.py

@@ -0,0 +1,155 @@
+"""
+FedRAMP 20x MCP Server - Documentation Tools
+
+This module contains tool implementation functions for documentation.
+"""
+import json
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+async def search_documentation_impl(keywords: str, data_loader) -> str:
+    """
+    Search FedRAMP documentation markdown files for specific keywords.
+    
+    This searches the official FedRAMP documentation from https://github.com/FedRAMP/docs/tree/main/docs
+    including guides, overviews, and detailed documentation for each standard.
+    
+    Args:
+        keywords: Keywords to search for in the documentation
+    
+    Returns:
+        Matching documentation sections with context
+    """
+    try:
+        # Ensure documentation is loaded
+        await data_loader.load_documentation()
+        
+        # Search documentation
+        results = data_loader.search_documentation(keywords)
+        
+        if not results:
+            return f"No documentation found matching '{keywords}'.\n\nTry:\n- Different keywords\n- More general terms\n- list_documentation_files() to see all available docs"
+        
+        result = f"# Documentation Search Results for '{keywords}'\n\n"
+        result += f"Found {len(results)} matches across FedRAMP documentation.\n\n"
+        
+        # Group results by file
+        by_file: Dict[str, List[Dict[str, Any]]] = {}
+        for match in results:
+            filename = match['filename']
+            if filename not in by_file:
+                by_file[filename] = []
+            by_file[filename].append(match)
+        
+        # Show results grouped by file (limit to first 10 files)
+        for filename in list(by_file.keys())[:10]:
+            matches = by_file[filename]
+            result += f"## {filename}\n\n"
+            result += f"{len(matches)} match(es) found\n\n"
+            
+            # Show first 3 matches from this file
+            for match in matches[:3]:
+                result += f"**Line {match['line_number']}:**\n"
+                result += f"```\n{match['context']}\n```\n\n"
+            
+            if len(matches) > 3:
+                result += f"*...and {len(matches) - 3} more matches in this file*\n\n"
+        
+        if len(by_file) > 10:
+            result += f"\n*Showing first 10 of {len(by_file)} files with matches. Refine your search for more specific results.*\n"
+        
+        result += "\n**Tip:** Use `get_documentation_file(filename)` to read the full content of any file.\n"
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error searching documentation for '{keywords}': {e}")
+        return f"Error searching documentation: {str(e)}"
+
+
+
+async def get_documentation_file_impl(filename: str, data_loader) -> str:
+    """
+    Get the full content of a specific FedRAMP documentation file.
+    
+    Args:
+        filename: The markdown filename (e.g., "overview.md", "key-security-indicators.md")
+    
+    Returns:
+        Full markdown content of the documentation file
+    """
+    try:
+        # Ensure documentation is loaded
+        await data_loader.load_documentation()
+        
+        # Get the file content
+        content = data_loader.get_documentation_file(filename)
+        
+        if not content:
+            available = data_loader.list_documentation_files()
+            return f"Documentation file '{filename}' not found.\n\n**Available files:**\n" + '\n'.join(f"- {f}" for f in available)
+        
+        result = f"# {filename}\n\n"
+        result += content
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error fetching documentation file '{filename}': {e}")
+        return f"Error retrieving documentation file: {str(e)}"
+
+
+
+async def list_documentation_files_impl(data_loader) -> str:
+    """
+    List all available FedRAMP documentation files.
+    
+    Returns:
+        List of all markdown documentation files from https://github.com/FedRAMP/docs/tree/main/docs
+    """
+    try:
+        # Ensure documentation is loaded
+        await data_loader.load_documentation()
+        
+        # Get list of files
+        files = data_loader.list_documentation_files()
+        
+        if not files:
+            return "No documentation files found."
+        
+        result = "# Available FedRAMP Documentation Files\n\n"
+        result += f"**Total:** {len(files)} files\n\n"
+        
+        # Group by type
+        standards = [f for f in files if f not in ['overview.md', 'guidelines.md', 'index.md'] and not f.startswith('20x') and not f.startswith('rev5')]
+        guides = [f for f in files if f in ['overview.md', 'guidelines.md', 'index.md']]
+        other = [f for f in files if f not in standards and f not in guides]
+        
+        if standards:
+            result += "## FedRAMP 20x Standards\n\n"
+            for f in sorted(standards):
+                result += f"- {f}\n"
+            result += "\n"
+        
+        if guides:
+            result += "## General Documentation\n\n"
+            for f in sorted(guides):
+                result += f"- {f}\n"
+            result += "\n"
+        
+        if other:
+            result += "## Other Documentation\n\n"
+            for f in sorted(other):
+                result += f"- {f}\n"
+            result += "\n"
+        
+        result += "**Usage:** Use `get_documentation_file(filename)` to read any file's full content.\n"
+        result += "**Search:** Use `search_documentation(keywords)` to find specific information.\n"
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error listing documentation files: {e}")
+        return f"Error listing documentation files: {str(e)}"