security-controls-mcp 0.2.0__py3-none-any.whl

security_controls_mcp/providers.py

@@ -0,0 +1,238 @@
+"""Provider abstraction for security standards."""
+
+import json
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+class StandardMetadata:
+    """Metadata about a security standard."""
+
+    def __init__(self, data: Dict[str, Any]):
+        """Initialize metadata from dictionary."""
+        self.standard_id = data.get("standard_id", "")
+        self.title = data.get("title", "")
+        self.version = data.get("version", "")
+        self.purchased_from = data.get("purchased_from", "")
+        self.purchase_date = data.get("purchase_date", "")
+        self.imported_date = data.get("imported_date", "")
+        self.license = data.get("license", "")
+        self.pages = data.get("pages", 0)
+        self.restrictions = data.get("restrictions", [])
+
+
+class SearchResult:
+    """A search result from a standard."""
+
+    def __init__(
+        self,
+        standard_id: str,
+        clause_id: str,
+        title: str,
+        content: str,
+        page: Optional[int] = None,
+        section_type: Optional[str] = None,
+    ):
+        """Initialize search result."""
+        self.standard_id = standard_id
+        self.clause_id = clause_id
+        self.title = title
+        self.content = content
+        self.page = page
+        self.section_type = section_type
+
+
+class StandardProvider(ABC):
+    """Abstract base class for standard providers."""
+
+    @abstractmethod
+    def get_metadata(self) -> StandardMetadata:
+        """Get metadata about this standard."""
+        pass
+
+    @abstractmethod
+    def search(self, query: str, limit: int = 10) -> List[SearchResult]:
+        """Search for content within the standard.
+
+        Args:
+            query: Search query string
+            limit: Maximum number of results to return
+
+        Returns:
+            List of search results
+        """
+        pass
+
+    @abstractmethod
+    def get_clause(self, clause_id: str) -> Optional[SearchResult]:
+        """Get a specific clause by ID.
+
+        Args:
+            clause_id: The clause/section identifier (e.g., "5.1.2", "A.5.15")
+
+        Returns:
+            The clause content, or None if not found
+        """
+        pass
+
+    @abstractmethod
+    def get_all_clauses(self) -> List[SearchResult]:
+        """Get all clauses in the standard.
+
+        Returns:
+            List of all clauses
+        """
+        pass
+
+
+class PaidStandardProvider(StandardProvider):
+    """Provider for paid standards loaded from JSON files."""
+
+    def __init__(self, standard_path: Path):
+        """Initialize provider from standard data directory.
+
+        Args:
+            standard_path: Path to standard data directory containing
+                          metadata.json and full_text.json
+        """
+        self.standard_path = standard_path
+        self.metadata_file = standard_path / "metadata.json"
+        self.full_text_file = standard_path / "full_text.json"
+
+        # Load data
+        self._load_data()
+
+    def _load_data(self) -> None:
+        """Load metadata and full text data."""
+        if not self.metadata_file.exists():
+            raise FileNotFoundError(f"Metadata file not found: {self.metadata_file}")
+
+        if not self.full_text_file.exists():
+            raise FileNotFoundError(f"Full text file not found: {self.full_text_file}")
+
+        with open(self.metadata_file, "r") as f:
+            self.metadata = StandardMetadata(json.load(f))
+
+        with open(self.full_text_file, "r") as f:
+            self.data = json.load(f)
+
+    def get_metadata(self) -> StandardMetadata:
+        """Get metadata about this standard."""
+        return self.metadata
+
+    def search(self, query: str, limit: int = 10) -> List[SearchResult]:
+        """Search for content within the standard."""
+        query_lower = query.lower()
+        results = []
+
+        # Search in sections
+        for section in self._iterate_sections(self.data.get("structure", {}).get("sections", [])):
+            if (
+                query_lower in section.get("content", "").lower()
+                or query_lower in section.get("title", "").lower()
+            ):
+                results.append(
+                    SearchResult(
+                        standard_id=self.metadata.standard_id,
+                        clause_id=section["id"],
+                        title=section["title"],
+                        content=section.get("content", "")[:500],  # Truncate for preview
+                        page=section.get("page"),
+                        section_type="section",
+                    )
+                )
+                if len(results) >= limit:
+                    return results
+
+        # Search in annexes
+        for annex in self.data.get("structure", {}).get("annexes", []):
+            for control in annex.get("controls", []):
+                if (
+                    query_lower in control.get("content", "").lower()
+                    or query_lower in control.get("title", "").lower()
+                ):
+                    results.append(
+                        SearchResult(
+                            standard_id=self.metadata.standard_id,
+                            clause_id=control["id"],
+                            title=control["title"],
+                            content=control.get("content", "")[:500],
+                            page=control.get("page"),
+                            section_type=f"Annex {annex['id']} - {control.get('category', 'control')}",
+                        )
+                    )
+                    if len(results) >= limit:
+                        return results
+
+        return results
+
+    def _iterate_sections(self, sections: List[Dict]) -> List[Dict]:
+        """Recursively iterate through sections and subsections."""
+        for section in sections:
+            yield section
+            # Recursively iterate subsections
+            if "subsections" in section:
+                yield from self._iterate_sections(section["subsections"])
+
+    def get_clause(self, clause_id: str) -> Optional[SearchResult]:
+        """Get a specific clause by ID."""
+        # Search in sections
+        for section in self._iterate_sections(self.data.get("structure", {}).get("sections", [])):
+            if section["id"] == clause_id:
+                return SearchResult(
+                    standard_id=self.metadata.standard_id,
+                    clause_id=section["id"],
+                    title=section["title"],
+                    content=section.get("content", ""),
+                    page=section.get("page"),
+                    section_type="section",
+                )
+
+        # Search in annexes
+        for annex in self.data.get("structure", {}).get("annexes", []):
+            for control in annex.get("controls", []):
+                if control["id"] == clause_id:
+                    return SearchResult(
+                        standard_id=self.metadata.standard_id,
+                        clause_id=control["id"],
+                        title=control["title"],
+                        content=control.get("content", ""),
+                        page=control.get("page"),
+                        section_type=f"Annex {annex['id']} - {control.get('category', 'control')}",
+                    )
+
+        return None
+
+    def get_all_clauses(self) -> List[SearchResult]:
+        """Get all clauses in the standard."""
+        results = []
+
+        # Get all sections
+        for section in self._iterate_sections(self.data.get("structure", {}).get("sections", [])):
+            results.append(
+                SearchResult(
+                    standard_id=self.metadata.standard_id,
+                    clause_id=section["id"],
+                    title=section["title"],
+                    content=section.get("content", "")[:200],  # Brief preview
+                    page=section.get("page"),
+                    section_type="section",
+                )
+            )
+
+        # Get all annex controls
+        for annex in self.data.get("structure", {}).get("annexes", []):
+            for control in annex.get("controls", []):
+                results.append(
+                    SearchResult(
+                        standard_id=self.metadata.standard_id,
+                        clause_id=control["id"],
+                        title=control["title"],
+                        content=control.get("content", "")[:200],
+                        page=control.get("page"),
+                        section_type=f"Annex {annex['id']}",
+                    )
+                )
+
+        return results

security_controls_mcp/registry.py

@@ -0,0 +1,132 @@
+"""Registry for managing all standard providers."""
+
+from typing import Dict, List, Optional
+
+from .config import Config
+from .providers import PaidStandardProvider, SearchResult, StandardProvider
+
+
+class StandardRegistry:
+    """Registry for all available standards (SCF + paid)."""
+
+    def __init__(self, config: Optional[Config] = None):
+        """Initialize the registry.
+
+        Args:
+            config: Configuration instance. If None, creates default config.
+        """
+        self.config = config or Config()
+        self.providers: Dict[str, StandardProvider] = {}
+
+        # Load all enabled paid standards
+        self._load_paid_standards()
+
+    def _load_paid_standards(self) -> None:
+        """Load all enabled paid standards from config."""
+        enabled_standards = self.config.get_enabled_standards()
+
+        for standard_id, standard_config in enabled_standards.items():
+            try:
+                standard_path = self.config.get_standard_path(standard_id)
+                if standard_path and standard_path.exists():
+                    provider = PaidStandardProvider(standard_path)
+                    self.providers[standard_id] = provider
+            except Exception as e:
+                # Log error but don't fail - just skip this standard
+                print(f"Warning: Could not load standard '{standard_id}': {e}")
+
+    def get_provider(self, standard_id: str) -> Optional[StandardProvider]:
+        """Get a provider by standard ID.
+
+        Args:
+            standard_id: The standard identifier
+
+        Returns:
+            The provider, or None if not found
+        """
+        return self.providers.get(standard_id)
+
+    def list_standards(self) -> List[Dict[str, str]]:
+        """List all available standards.
+
+        Returns:
+            List of dictionaries with standard information
+        """
+        standards = []
+
+        # Add SCF (always available)
+        standards.append(
+            {
+                "standard_id": "scf",
+                "title": "Secure Controls Framework (SCF) 2025.4",
+                "type": "built-in",
+                "license": "Creative Commons BY-ND 4.0",
+                "controls": "1,451 controls across 16 frameworks",
+            }
+        )
+
+        # Add paid standards
+        for standard_id, provider in self.providers.items():
+            metadata = provider.get_metadata()
+            standards.append(
+                {
+                    "standard_id": standard_id,
+                    "title": metadata.title,
+                    "type": "paid",
+                    "license": metadata.license,
+                    "version": metadata.version,
+                    "purchased_from": metadata.purchased_from,
+                    "purchase_date": metadata.purchase_date,
+                }
+            )
+
+        return standards
+
+    def search_all(self, query: str, limit: int = 20) -> Dict[str, List[SearchResult]]:
+        """Search across all available paid standards.
+
+        Args:
+            query: Search query string
+            limit: Maximum total results
+
+        Returns:
+            Dictionary mapping standard_id to list of search results
+        """
+        all_results = {}
+        results_per_standard = max(5, limit // max(1, len(self.providers)))
+
+        for standard_id, provider in self.providers.items():
+            results = provider.search(query, limit=results_per_standard)
+            if results:
+                all_results[standard_id] = results
+
+        return all_results
+
+    def get_clause_from_any_standard(self, clause_id: str) -> Optional[tuple[str, SearchResult]]:
+        """Search for a clause across all standards.
+
+        Args:
+            clause_id: The clause identifier to search for
+
+        Returns:
+            Tuple of (standard_id, SearchResult) if found, None otherwise
+        """
+        for standard_id, provider in self.providers.items():
+            result = provider.get_clause(clause_id)
+            if result:
+                return (standard_id, result)
+
+        return None
+
+    def has_paid_standards(self) -> bool:
+        """Check if any paid standards are loaded.
+
+        Returns:
+            True if at least one paid standard is available
+        """
+        return len(self.providers) > 0
+
+    def reload(self) -> None:
+        """Reload all standards from config."""
+        self.providers.clear()
+        self._load_paid_standards()