mcp-server-for-oscal 0.1.5__py3-none-any.whl

mcp_server_for_oscal/tools/__init__.py

@@ -0,0 +1,5 @@
+"""
+OSCAL MCP Server Tools
+
+This package contains all the tool functions for the OSCAL MCP server.
+"""

mcp_server_for_oscal/tools/get_schema.py

@@ -0,0 +1,101 @@
+"""
+Tool for retrieving OSCAL schemas.
+"""
+
+import asyncio
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+from mcp.server.fastmcp.server import Context
+from strands import tool
+
+from mcp_server_for_oscal.tools.utils import OSCALModelType, schema_names
+
+logger = logging.getLogger(__name__)
+
+
+@tool
+def get_oscal_schema(
+    ctx: Context, model_name: str = "complete", schema_type: str = "json"
+) -> str:
+    """
+    A tool that returns the schema for specified OSCAL model. Try this tool first for any questions about the structure of OSCAL models.
+    By default we return a JSON schema, but `schema_type` parameter can change that behavior. You can use the list_models tool to get
+    a list of valid model names.
+
+    Args:
+        ctx: MCP server context (should be injected automatically by MCP server)
+        model_name: The name of the OSCAL model. If no value is provided, then we return a "complete" schema including all models, which is large.
+        schema_type: If `json` (default) then return the JSON schema for the specified model. Otherwise, return its XSD (XML) schema.
+
+    Returns:
+        str: The requested schema as JSON string
+    """
+    logger.debug(
+        "get_oscal_model_schema(model_name: %s, syntax: %s, session client params: %s)",
+        model_name,
+        schema_type,
+        ctx.session.client_params,
+    )
+
+    if schema_type not in ["json", "xsd"]:
+        msg = f"Invalid schema type: {schema_type}."
+        if ctx is not None:
+            try:
+                loop = asyncio.get_running_loop()
+                # Already in async context - can't use asyncio.run()
+                loop.run_until_complete(ctx.error(msg))
+            except RuntimeError:
+                # Not in async context - safe to use asyncio.run()
+                asyncio.run(ctx.error(msg))
+        raise ValueError(msg)
+
+    if (
+        model_name not in OSCALModelType.__members__.values()
+        and model_name != "complete"
+    ):
+        msg = f"Invalid model: {model_name}. Use the tool list_oscal_models to get valid model names."
+        if ctx is not None:
+            try:
+                loop = asyncio.get_running_loop()
+                # Already in async context - can't use asyncio.run()
+                loop.run_until_complete(ctx.error(msg))
+            except RuntimeError:
+                # Not in async context - safe to use asyncio.run()
+                asyncio.run(ctx.error(msg))
+        raise ValueError(msg)
+
+    schema_file_name = f"{schema_names.get(model_name)}.{schema_type}"
+
+    try:
+        schema = json.load(open_schema_file(schema_file_name))
+    except Exception:
+        msg = f"failed to open schema {schema_file_name}"
+        logger.exception(msg)
+        if ctx is not None:
+            try:
+                loop = asyncio.get_running_loop()
+                # Already in async context - can't use asyncio.run()
+                loop.run_until_complete(ctx.error(msg))
+            except RuntimeError:
+                # Not in async context - safe to use asyncio.run()
+                asyncio.run(ctx.error(msg))
+        raise
+
+    return json.dumps(schema)
+
+
+def open_schema_file(file_name: str) -> Any:
+    """Open a schema file from the OSCAL schemas directory."""
+    # Get the directory of this file and navigate to oscal_schemas relative to it
+    current_file_dir = Path(__file__).parent
+    schema_path = current_file_dir.parent.joinpath("oscal_schemas")
+
+    try:
+        return open(schema_path.joinpath(file_name.lstrip("./\\")))
+    except Exception:
+        msg = f"failed to open file {file_name}"
+        logger.exception(msg)
+        raise

mcp_server_for_oscal/tools/list_models.py

@@ -0,0 +1,79 @@
+"""
+Tool for listing available OSCAL model types.
+"""
+
+from strands import tool
+
+from mcp_server_for_oscal.tools.utils import OSCALModelType
+
+
+@tool
+def list_oscal_models() -> dict:
+    """
+    List all available OSCAL model types with metadata.
+
+    Returns:
+        dict: List of OSCAL models where the key is model's name as used 
+            in the schema, and value is an object that includes description,
+            layer, formal and short names, and release status.
+    """
+    models = {
+        OSCALModelType.CATALOG: {
+            "description": "A structured set of controls and control enhancements",
+            "layer": "Control",
+            "formalName": "Catalog",
+            "shortName": "catalog",
+            "status": "GA",
+        },
+        OSCALModelType.PROFILE: {
+            "description": "A baseline or overlay that selects and customizes controls from catalogs",
+            "layer": "Control",
+            "formalName": "Profile",
+            "shortName": "profile",
+            "status": "GA",
+        },
+        OSCALModelType.MAPPING: {
+            "description": "Describes how a collection of security controls relates to another collection of controls",
+            "layer": "Control",
+            "formalName": "Mapping Collection",
+            "shortName": "mapping",
+            "status": "GA",
+        },
+        OSCALModelType.COMPONENT_DEFINITION: {
+            "description": "Describes how components implement controls",
+            "layer": "Implementation",
+            "formalName": "Component Definition",
+            "shortName": "component",
+            "status": "GA",
+        },
+        OSCALModelType.SYSTEM_SECURITY_PLAN: {
+            "description": "Documents how a system implements required controls",
+            "layer": "Implementation",
+            "formalName": "System Security Plan (SSP)",
+            "shortName": "SSP",
+            "status": "GA",
+        },
+        OSCALModelType.ASSESSMENT_PLAN: {
+            "description": "Defines how controls will be assessed",
+            "layer": "Assessment",
+            "formalName": "Security Assessment Plan (SAP)",
+            "shortName": "AP",
+            "status": "GA",
+        },
+        OSCALModelType.ASSESSMENT_RESULTS: {
+            "description": "Documents the results of control assessments",
+            "layer": "Assessment",
+            "formalName": "Security Assessment Results (SAR)",
+            "shortName": "AR",
+            "status": "GA",
+        },
+        OSCALModelType.PLAN_OF_ACTION_AND_MILESTONES: {
+            "description": "Documents remediation plans for identified issues",
+            "layer": "Assessment",
+            "formalName": "Plan of Action and Milestones (POA&M)",
+            "shortName": "POAM",
+            "status": "GA",
+        },
+    }
+
+    return models

mcp_server_for_oscal/tools/list_oscal_resources.py

@@ -0,0 +1,123 @@
+"""
+Tool for listing OSCAL community resources.
+"""
+
+import logging
+import asyncio
+from pathlib import Path
+from typing import Any
+
+from mcp.server.fastmcp.server import Context
+from strands import tool
+
+logger = logging.getLogger(__name__)
+
+
+@tool
+def list_oscal_resources(ctx: Context) -> str:
+    """
+    Retrieve a comprehensive directory of OSCAL community resources and tools.
+
+    This tool provides access to a curated collection of OSCAL (Open Security Controls Assessment Language)
+    community resources that can help users:
+
+    - Find OSCAL-compatible tools and software implementations
+    - Discover educational content, tutorials, and documentation
+    - Access example OSCAL documents and templates
+    - Locate presentations, articles, and research papers about OSCAL
+    - Identify government and industry adoption examples
+    - Find libraries and SDKs for OSCAL development
+    - Access validation tools and utilities
+
+    The returned content is structured markdown that categorizes resources by type (tools, content,
+    presentations, etc.) making it easy to find specific types of OSCAL resources based on user needs.
+
+    Use this tool when users ask about:
+    - "What OSCAL tools are available?"
+    - "How can I learn more about OSCAL?"
+    - "Are there examples of OSCAL implementations?"
+    - "What resources exist for OSCAL development?"
+    - "Who is using OSCAL in production?"
+
+    Args:
+        ctx: MCP server context (should be injected automatically by MCP server)
+
+    Returns:
+        str: Complete markdown content containing categorized OSCAL community resources,
+             tools, documentation, examples, and educational materials
+
+    Raises:
+        FileNotFoundError: If the awesome-oscal.md file cannot be found
+        IOError: If there are issues reading the file
+        UnicodeDecodeError: If there are encoding issues with the file
+    """
+    logger.debug(
+        "list_oscal_resources() called with session client params: %s",
+        ctx.session.client_params if ctx else None,
+    )
+
+    try:
+        content = read_resources_file()
+        logger.debug("Successfully read OSCAL resources file")
+        return content
+    except Exception:
+        msg = "Failed to read OSCAL resources file."
+        logger.exception(msg)
+        if ctx is not None:
+            try:
+                loop = asyncio.get_running_loop()
+                # Already in async context - can't use asyncio.run()
+                loop.run_until_complete(ctx.error(msg))
+            except RuntimeError:
+                # Not in async context - safe to use asyncio.run()
+                result = asyncio.run(ctx.error(msg))
+        raise
+
+
+def read_resources_file() -> str:
+    """
+    Read the awesome-oscal.md file from the oscal_docs directory.
+
+    Returns:
+        str: The complete content of the awesome-oscal.md file
+
+    Raises:
+        FileNotFoundError: If the awesome-oscal.md file cannot be found
+        IOError: If there are issues reading the file
+        UnicodeDecodeError: If there are encoding issues with the file
+    """
+    # Get the directory of this file and navigate to oscal_docs relative to it
+    current_file_dir = Path(__file__).parent
+    docs_path = current_file_dir.parent / "oscal_docs"
+    resources_file_path = docs_path / "awesome-oscal.md"
+
+    logger.debug("Reading OSCAL resources from: %s", resources_file_path)
+
+    try:
+        # Read with explicit UTF-8 encoding and error handling
+        with open(resources_file_path, "r", encoding="utf-8", errors="strict") as file:
+            content = file.read()
+
+        if not content.strip():
+            logger.warning("OSCAL resources file is empty")
+
+        return content
+    except FileNotFoundError:
+        logger.error("OSCAL resources file not found at: %s", resources_file_path)
+        raise
+    except UnicodeDecodeError as e:
+        logger.error("Encoding error reading file %s: %s", resources_file_path, e)
+        # Try with different encoding as fallback
+        try:
+            with open(
+                resources_file_path, "r", encoding="latin-1", errors="replace"
+            ) as file:
+                content = file.read()
+            logger.warning("Successfully read file with latin-1 encoding fallback")
+            return content
+        except Exception as fallback_error:
+            logger.error("Fallback encoding also failed: %s", fallback_error)
+            raise e  # Raise the original UnicodeDecodeError
+    except (IOError, OSError) as e:
+        logger.error("IO error reading file %s: %s", resources_file_path, e)
+        raise

mcp_server_for_oscal/tools/query_documentation.py

@@ -0,0 +1,75 @@
+"""
+Tool for querying OSCAL documentation from Amazon Bedrock Knowledge Base.
+"""
+
+import json
+import logging
+from typing import Any
+
+from boto3 import Session
+from mcp.server.fastmcp.server import Context
+from strands import tool
+
+from mcp_server_for_oscal.config import config
+
+logger = logging.getLogger(__name__)
+logger.setLevel(config.log_level)
+
+
+@tool
+def query_oscal_documentation(query: str, ctx: Context) -> Any:
+    """
+    A tool to query OSCAL-related documentation. Use this tool when a question about OSCAL cannot be answered just by analyzing model schemas. In case the question is about an explicit property of an OSCAL model, try to find the answer using the get_schema tool first.
+
+    Args:
+        query: Question or search query about OSCAL
+
+    Returns:
+        dict: Results retrieved from knowledge base, structured as a Bedrock RetrieveResponseTypeDef object.
+    """
+    if config.knowledge_base_id is None:
+        msg = "Knowledge base ID is not set. Please set the OSCAL_KB_ID environment variable."
+        logger.warning(msg)
+        if ctx is not None:
+            garbage = ctx.warning(msg)
+        return query_local(query, ctx)
+    return query_kb(query, ctx)
+
+
+def query_kb(query: str, ctx: Context) -> Any:
+    """Query Amazon Bedrock Knowledgebase using Boto SDK."""
+    try:
+        # Initialize boto session with the configured profile
+        aws_profile = config.aws_profile
+        if aws_profile:
+            logger.debug(f"Using AWS profile: {aws_profile}")
+            s = Session(profile_name=aws_profile)
+        else:
+            logger.debug("Using default AWS profile or environment credentials")
+            s = Session()
+
+        # Query Amazon Bedrock Knowledgebase using Boto SDK
+        answer = s.client("bedrock-agent-runtime").retrieve(
+            knowledgeBaseId=config.knowledge_base_id, retrievalQuery={"text": query}
+        )
+
+        logger.debug(json.dumps(answer, indent=1))
+
+        return answer
+
+    except Exception as e:
+        msg = f"Error running query {query} documentation: {e}"
+        logger.exception(msg)
+        if ctx is not None:
+            garbage = ctx.error(msg)
+        raise
+
+
+def query_local(query: str, ctx: Context) -> Any:
+    msg = "Not yet implemented"
+    logger.error(msg)
+    if ctx is not None:
+        garbage = ctx.error(msg)
+    return {
+        "error": msg,
+    }

mcp_server_for_oscal/tools/utils.py

@@ -0,0 +1,37 @@
+"""
+Shared utilities for OSCAL MCP tools.
+"""
+
+# import os.path
+import logging
+
+# from typing import Any
+from enum import StrEnum
+
+logger = logging.getLogger(__name__)
+
+
+class OSCALModelType(StrEnum):
+    """Enumeration of OSCAL model types."""
+    # These values are intended to match the root object name in the JSON schema
+    CATALOG = "catalog"
+    PROFILE = "profile"
+    COMPONENT_DEFINITION = "component-definition"
+    SYSTEM_SECURITY_PLAN = "system-security-plan"
+    ASSESSMENT_PLAN = "assessment-plan"
+    ASSESSMENT_RESULTS = "assessment-results"
+    PLAN_OF_ACTION_AND_MILESTONES = "plan-of-action-and-milestones"
+    MAPPING = "mapping-collection"
+
+
+schema_names = {
+    OSCALModelType.ASSESSMENT_PLAN: "oscal_assessment-plan_schema",
+    OSCALModelType.ASSESSMENT_RESULTS: "oscal_assessment-results_schema",
+    OSCALModelType.CATALOG: "oscal_catalog_schema",
+    OSCALModelType.COMPONENT_DEFINITION: "oscal_component_schema",
+    OSCALModelType.MAPPING: "oscal_mapping_schema",
+    OSCALModelType.PROFILE: "oscal_profile_schema",
+    OSCALModelType.PLAN_OF_ACTION_AND_MILESTONES: "oscal_poam_schema",
+    OSCALModelType.SYSTEM_SECURITY_PLAN: "oscal_ssp_schema",
+    "complete": "oscal_complete_schema"
+}

mcp_server_for_oscal-0.1.5.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: mcp-server-for-oscal
+Version: 0.1.5
+Summary: AI agent tools for Open Security Controls Assessment Language (OSCAL).
+License-File: LICENSE
+License-File: NOTICE
+Requires-Python: >=3.11
+Requires-Dist: boto3>=1.42.7
+Requires-Dist: mcp>=1.23.3
+Requires-Dist: strands-agents>=1.19.0
+Description-Content-Type: text/markdown
+
+# MCP Server for OSCAL
+
+A Model Context Protocol (MCP) server that provides AI assistants (Claude, Cline, Kiro, Claude Code, etc.) with tools to work with NIST's Open Security Controls Assessment Language (OSCAL). Like many early adopters, we needed help implementing OSCAL proofs-of-concept to demonstrate value to business stakeholders. Perhaps due to limited availability of examples in the public domain, we found that most AI agents/LLMs alone produced inconsistent results related to OSCAL. The tools in this MCP server minimzed that problem for our use-case and we hope they do the same for you. 
+
+## What is OSCAL?
+
+[OSCAL (Open Security Controls Assessment Language)](https://pages.nist.gov/OSCAL/) is a set of framework-agnostic, vendor-neutral, machine-readable schemas developed by NIST that describe the full life cycle of GRC (governance, risk, compliance) artifacts, from controls to remediation plans. OSCAL enables automation of GRC workflows by replacing digital paper (spreadsheets, PDFs, etc.) with a standard-based structured data format.
+## Features
+
+This MCP server provides [tools](src/mcp_server_for_oscal/tools/) for working with OSCAL:
+
+### 1. List OSCAL Models  
+- **Tool**: `list_oscal_models`
+- Retrieve all available OSCAL model types with descriptions, layers, and status
+- Understand the different OSCAL models and their purposes
+
+### 2. Get OSCAL Schemas
+- **Tool**: `get_oscal_schema`  
+- Retrieve JSON or XSD schemas for current GA release of individual OSCAL models. Because OSCAL schemas are self-documenting, this is equivalent to querying model documentation.
+- Used to answer questions about the structure, properties, requirements of each OSCAL model
+
+### 3. List OSCAL Community Resources
+- **Tool**: `list_oscal_resources`
+- Access a curated collection of OSCAL community resources from [Awesome OSCAL](https://github.com/oscal-club/awesome-oscal)
+- Get information about available OSCAL tools, content, articles, presentations, and educational materials
+- Includes resources from government agencies, security organizations, and the broader OSCAL community
+
+### 4. Query OSCAL Documentation
+- **Tool**: `query_oscal_documentation`
+- Query authoritative OSCAL documentation using Amazon Bedrock Knowledge Base (KB). Note that this feature requires you to setup and maintain a Bedrock KB in your AWS account. In future, we hope to provide this as a service.
+- Get answers to questions about OSCAL concepts, best practices, and implementation guidance.
+
+## Installation
+If you just want to use the MCP server with your IDE or preferred AI tool, then you don't need to clone the project or download source code. 
+### Prerequisites
+
+- `uv` package manager for Python [(Installation instructions)](https://docs.astral.sh/uv/getting-started/installation/)
+- Python 3.11 or higher; [(`uv install python 3.12`)](https://docs.astral.sh/uv/guides/install-python/). The server may work with other versions of Python, but we only test 3.11 & 3.12 for now.
+
+### Configuring IDEs and AI Tools
+
+This MCP server communicates via stdio (standard input/output) and can be integrated with various IDEs and agentic tools that support the Model Context Protocol.
+
+#### Configuration Format
+
+Most MCP-compatible tools use a JSON configuration format described in the [FastMCP documentation](https://gofastmcp.com/integrations/mcp-json-configuration). Here's the basic structure:
+
+```json
+{
+  "mcpServers": {
+    "oscal": {
+      "command": "uvx",
+      "args": ["--from", "mcp-server-for-oscal@latest", "server"],
+      "env": {
+      }
+    }
+  }
+}
+```
+
+#### IDE-Specific Configuration
+
+**Kiro IDE**
+See [Kiro's MCP documentation](https://kiro.dev/docs/mcp/configuration/) for additional options. Add to your `.kiro/settings/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "oscal": {
+      "command": "uvx",
+      "args": ["--from", "mcp-server-for-oscal@latest", "server"],
+      "env": {},
+      "disabled": false,
+      "autoApprove": [
+        "get_oscal_schema",
+        "list_oscal_resources",
+        "list_oscal_models",
+        "query_oscal_documentation"
+      ]
+    }
+  }
+}
+```
+
+**Claude Desktop**
+Add to your `~/.claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "oscal": {
+      "command": "uvx",
+      "args": ["--from", "mcp-server-for-oscal@latest", "server"]
+    }
+  }
+}
+```
+
+**VS Code**
+Run the `MCP: Open User Configuration` command, which opens the mcp.json file in your user profile. You can then manually add the server configuration to the file. See the [VSCode/Copilot docs](https://code.visualstudio.com/docs/copilot/customization/mcp-servers#_add-an-mcp-server) for addtional options and details.
+
+```json
+{
+  "servers": [
+    "oscal": {
+      "command": "uvx",
+      "args": ["--from", "mcp-server-for-oscal@latest", "server"]
+    }
+  ]
+}
+```
+
+#### Environment Variables
+Generally, configuration should not be required. See the file [dotenv.example](dotenv.example) for available options. Note that a dotenv file is only needed in a development environment. For typical, runtime use of the MCP server, environment variables should be configured as described in the [FastMCP documentation](https://gofastmcp.com/integrations/mcp-json-configuration#env-optional).
+
+## Development
+See [DEVELOPING](DEVELOPING.md) to get started.
+
+## Security
+
+See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.
+
+## License
+
+This project is licensed under the [Apache-2.0](LICENSE) License.

mcp_server_for_oscal-0.1.5.dist-info/RECORD

@@ -0,0 +1,38 @@
+mcp_server_for_oscal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_server_for_oscal/__main__.py,sha256=qrmsifNBPjwmKSrpdCdLgk9EffBmy4LpvQ9X_aAZxVM,170
+mcp_server_for_oscal/config.py,sha256=zQx0KVC_wVIBRP0ClD0NpoUd2uH126VuHCRcoKPSuRU,2340
+mcp_server_for_oscal/main.py,sha256=G89YH78KmD_C5dD4n_iIUKX5d880-ulf0stkcaapO-M,4275
+mcp_server_for_oscal/oscal_agent.py,sha256=zSEusbCh6oQGzC0dfOvgMh4HiChufVKxtk2dYelK-Ac,1424
+mcp_server_for_oscal/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_server_for_oscal/oscal_docs/awesome-oscal.md,sha256=QQXcXMfw9pnx1EKOEa7sKNq2cYBtSOW0gLY-8Qj8kd4,20684
+mcp_server_for_oscal/oscal_schemas/README.md,sha256=QOiuHFR6aJoCddNAqC1ha7ZZj53RGMfKi9GMw-fGWo4,4672
+mcp_server_for_oscal/oscal_schemas/oscal_assessment-plan_schema.json,sha256=ILvWO55KGslPlIb-b86AEgR99uuw8iv4R39WYGUalTc,105944
+mcp_server_for_oscal/oscal_schemas/oscal_assessment-plan_schema.xsd,sha256=eBjC_nSqUWXZZHYCyddL_uF65q9dflcDy9bmdsY0KnE,318162
+mcp_server_for_oscal/oscal_schemas/oscal_assessment-results_schema.json,sha256=VHkA2AdK_RRLtHsEOh3rCPwsZKDgB5zBzrypdhjw_2o,111568
+mcp_server_for_oscal/oscal_schemas/oscal_assessment-results_schema.xsd,sha256=fuoNIQjuDbq_pHWSgg8hCnUgYiviDGGPPF5FuPk1uzg,337785
+mcp_server_for_oscal/oscal_schemas/oscal_catalog_schema.json,sha256=nZksKELAaXPqswdTdySq8-5tKvVsvsPzlLKflDF2f5w,40440
+mcp_server_for_oscal/oscal_schemas/oscal_catalog_schema.xsd,sha256=I40mYyirjylx9YDpdsIs_EBG1ApkoKwmbaetf4DMcv0,111511
+mcp_server_for_oscal/oscal_schemas/oscal_complete_schema.json,sha256=hKFCbaiKfC_n8dQd1jMh-GTLA-LrUlawlnmtZdimaD8,202768
+mcp_server_for_oscal/oscal_schemas/oscal_complete_schema.xsd,sha256=MfOgKjgx4gUfr1VimRZaRniz1mGRDTOX_2wdI0l8J-U,567360
+mcp_server_for_oscal/oscal_schemas/oscal_component_schema.json,sha256=Em6kfd6V_e0pSbGGJMvM3WFKaa8nozdTdAYyKI1MWls,61961
+mcp_server_for_oscal/oscal_schemas/oscal_component_schema.xsd,sha256=fXxXBrbFZ6kXOCXO2wsSeZgQ93Oww_8vhPjFd3s0egU,169052
+mcp_server_for_oscal/oscal_schemas/oscal_mapping_schema.json,sha256=Avm8PDxknE3co33ZzHmKENNO3_bkODnH7cwiBu2nchs,43295
+mcp_server_for_oscal/oscal_schemas/oscal_mapping_schema.xsd,sha256=pRSGdZkJJ0UqtdjQhFbGDSIMgAltf88cNB1W8qj2das,123704
+mcp_server_for_oscal/oscal_schemas/oscal_poam_schema.json,sha256=U8C9jOOHxd9ZPbtYX0oOE_C7JDDgzCHsxKUWw4i4n9w,108642
+mcp_server_for_oscal/oscal_schemas/oscal_poam_schema.xsd,sha256=fr2pKmmK96ANEjr02gqJC8NzkOOu5UCbD4vQkJdXf1o,326269
+mcp_server_for_oscal/oscal_schemas/oscal_profile_schema.json,sha256=hUwSfnXhzu_o0s1hRUfZOkbDNAdBkgQ5hW_ReQXPJjI,49871
+mcp_server_for_oscal/oscal_schemas/oscal_profile_schema.xsd,sha256=N09ONO-eSapidl3C7KZmgZbeT4LBTvVLkTrgMnRy0ek,136763
+mcp_server_for_oscal/oscal_schemas/oscal_ssp_schema.json,sha256=WrWfNHHlPxUHPEGJcjjx0XATvZhUF7Z5C78R4TrgB30,80359
+mcp_server_for_oscal/oscal_schemas/oscal_ssp_schema.xsd,sha256=VzJ845-ZEiQKAPM39jXq5pi_StgrXpmX6w27zhpYfxE,237445
+mcp_server_for_oscal/tools/__init__.py,sha256=bq10TtkxFCTpTTLsz-9OPoTsANdQS9gy6nH6Qi8iNpg,103
+mcp_server_for_oscal/tools/get_schema.py,sha256=x0LyU2gYD4K1YB_ZZpohpqvsT99l0eROrJrgebWudOo,3644
+mcp_server_for_oscal/tools/list_models.py,sha256=yvs3n1hVb0uMCsC61jd5_qyPDoud2mhzXtFhsSMj2R4,2829
+mcp_server_for_oscal/tools/list_oscal_resources.py,sha256=KvoE_L-rdA_O9uOlLblKNMtrk93zBgy8bR7i6yGVsno,4595
+mcp_server_for_oscal/tools/query_documentation.py,sha256=rTsr8pzJ-kjWRFJLsgEI5vHPiYneze8ATlOOSgdfou8,2372
+mcp_server_for_oscal/tools/utils.py,sha256=SSpwh-Vd01IQSm19pW4Iffw_kYU78TYQlOw1qlfKTnw,1221
+mcp_server_for_oscal-0.1.5.dist-info/METADATA,sha256=PupTPUP88c8tZySfAuTKHTMLLMDaYLJOrhD6N8IQRzc,5816
+mcp_server_for_oscal-0.1.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mcp_server_for_oscal-0.1.5.dist-info/entry_points.txt,sha256=V2fi4mxQL6L1jEQPi2Vt0UpJhqZ-NPmTf3sQbHlg0io,58
+mcp_server_for_oscal-0.1.5.dist-info/licenses/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+mcp_server_for_oscal-0.1.5.dist-info/licenses/NOTICE,sha256=1CkO1kwu3Q_OHYTj-d-yiBJA_lNN73a4zSntavaD4oc,67
+mcp_server_for_oscal-0.1.5.dist-info/RECORD,,

mcp_server_for_oscal-0.1.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mcp_server_for_oscal-0.1.5.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+server = mcp_server_for_oscal.main:main