kcaa 0.1.0__py3-none-any.whl

kcaa/__init__.py

@@ -0,0 +1,29 @@
+"""
+KiCad MCP Server.
+
+A Model Context Protocol (MCP) server for KiCad electronic design automation (EDA) files.
+"""
+from .server import *
+from .config import *
+from .context import *
+
+__version__ = "0.1.0"
+__author__ = "Lama Al Rajih"
+__description__ = "Model Context Protocol server for KiCad on Mac, Windows, and Linux"
+
+__all__ = [
+    # Package metadata
+    "__version__",
+    "__author__",
+    "__description__",
+
+    # Server creation / shutdown helpers
+    "create_server",
+    "add_cleanup_handler",
+    "run_cleanup_handlers",
+    "shutdown_server",
+
+    # Lifespan / context helpers
+    "kicad_lifespan",
+    "KiCadAppContext",
+]

kcaa/config.py

@@ -0,0 +1,328 @@
+"""
+Configuration settings for the KiCad MCP server.
+
+This module provides platform-specific configuration for KiCad integration,
+including file paths, extensions, component libraries, and operational constants.
+All settings are determined at import time based on the operating system.
+
+Module Variables:
+    system (str): Operating system name from platform.system()
+    KICAD_VERSION (str): KiCad version string used to construct versioned paths
+    KICAD_USER_DIR (str): User's KiCad documents directory
+    KICAD_APP_PATH (str): KiCad application installation path
+    ADDITIONAL_SEARCH_PATHS (List[str]): Additional project search locations
+    DEFAULT_PROJECT_LOCATIONS (List[str]): Common project directory patterns
+    KICAD_PYTHON_BASE (str): KiCad Python framework base path (macOS only)
+    KICAD_EXTENSIONS (Dict[str, str]): KiCad file extension mappings
+    DATA_EXTENSIONS (List[str]): Recognized data file extensions
+    CIRCUIT_DEFAULTS (Dict[str, Union[float, List[float]]]): Default circuit parameters
+    COMMON_LIBRARIES (Dict[str, Dict[str, Dict[str, str]]]): Component library mappings
+    DEFAULT_FOOTPRINTS (Dict[str, List[str]]): Default footprint suggestions per component
+    TIMEOUT_CONSTANTS (Dict[str, float]): Operation timeout values in seconds
+    PROGRESS_CONSTANTS (Dict[str, int]): Progress reporting percentage values
+    DISPLAY_CONSTANTS (Dict[str, int]): UI display configuration values
+    LibraryPathConfig: Configuration class for symbol library paths and settings
+
+Platform Support:
+    - macOS (Darwin): Full support with application bundle paths
+    - Windows: Standard installation paths
+    - Linux: System package paths
+    - Unknown: Defaults to macOS paths for compatibility
+
+Dependencies:
+    - os: File system operations and environment variables
+    - platform: Operating system detection
+"""
+
+import logging
+import os
+import platform
+
+log = logging.getLogger(__name__)
+
+# Determine operating system for platform-specific configuration
+# Returns 'Darwin' (macOS), 'Windows', 'Linux', or other
+system = platform.system()
+
+# Platform-specific KiCad installation and user directory paths
+# These paths are used for finding KiCad resources and user projects
+if system == "Darwin":  # macOS
+    KICAD_USER_DIR = os.path.expanduser("~/Documents/KiCad")
+    KICAD_APP_PATH = "/Applications/KiCad/KiCad.app"
+elif system == "Windows":
+    KICAD_USER_DIR = os.path.expanduser("~/Documents/KiCad")
+    KICAD_APP_PATH = r"C:\Program Files\KiCad"
+elif system == "Linux":
+    KICAD_USER_DIR = os.path.expanduser("~/KiCad")
+    KICAD_APP_PATH = "/usr/share/kicad"
+else:
+    # Default to macOS paths if system is unknown for maximum compatibility
+    # This ensures the server can start even on unrecognized platforms
+    KICAD_USER_DIR = os.path.expanduser("~/Documents/KiCad")
+    KICAD_APP_PATH = "/Applications/KiCad/KiCad.app"
+
+# Additional search paths from environment variable KICAD_SEARCH_PATHS
+# Users can specify custom project locations as comma-separated paths
+ADDITIONAL_SEARCH_PATHS = []
+env_search_paths = os.environ.get("KICAD_SEARCH_PATHS", "")
+if env_search_paths:
+    for path in env_search_paths.split(","):
+        expanded_path = os.path.expanduser(path.strip())  # Expand ~ and variables
+        if os.path.exists(expanded_path):  # Only add existing directories
+            ADDITIONAL_SEARCH_PATHS.append(expanded_path)
+
+# Auto-detect common project locations for convenient project discovery
+# These are typical directory names users create for electronics projects
+DEFAULT_PROJECT_LOCATIONS = [
+    "~/Documents/PCB",  # Common Windows/macOS location
+    "~/PCB",  # Simple home directory structure
+    "~/Electronics",  # Generic electronics projects
+    "~/Projects/Electronics",  # Organized project structure
+    "~/Projects/PCB",  # PCB-specific project directory
+    "~/Projects/KiCad",  # KiCad-specific project directory
+]
+
+# Add existing default locations to search paths
+# Avoids duplicates and only includes directories that actually exist
+for location in DEFAULT_PROJECT_LOCATIONS:
+    expanded_path = os.path.expanduser(location)
+    if os.path.exists(expanded_path) and expanded_path not in ADDITIONAL_SEARCH_PATHS:
+        ADDITIONAL_SEARCH_PATHS.append(expanded_path)
+
+# Base path to KiCad's Python framework for API access
+# macOS bundles Python framework within the application
+if system == "Darwin":  # macOS
+    KICAD_PYTHON_BASE = os.path.join(
+        KICAD_APP_PATH, "Contents/Frameworks/Python.framework/Versions"
+    )
+else:
+    # Linux/Windows use system Python or require dynamic detection
+    KICAD_PYTHON_BASE = ""  # Will be determined dynamically in python_path.py
+
+
+# KiCad file extension mappings for project file identification
+# Used by file discovery and validation functions
+KICAD_EXTENSIONS = {
+    "project": ".kicad_pro",
+    "pcb": ".kicad_pcb",
+    "schematic": ".kicad_sch",
+    "design_rules": ".kicad_dru",
+    "worksheet": ".kicad_wks",
+    "footprint": ".kicad_mod",
+    "netlist": "_netlist.net",
+    "kibot_config": ".kibot.yaml",
+}
+
+# Additional data file extensions that may be part of KiCad projects
+# Includes manufacturing files, component data, and export formats
+DATA_EXTENSIONS = [
+    ".csv",  # BOM or other data
+    ".pos",  # Component position file
+    ".net",  # Netlist files
+    ".zip",  # Gerber files and other archives
+    ".drl",  # Drill files
+]
+
+# Default parameters for circuit creation and component placement
+# Values in mm unless otherwise specified, following KiCad conventions
+CIRCUIT_DEFAULTS = {
+    "grid_spacing": 1.0,  # Default grid spacing in mm for user coordinates
+    "component_spacing": 10.16,  # Default component spacing in mm
+    "wire_width": 6,  # Default wire width in KiCad units (0.006 inch)
+    "text_size": [1.27, 1.27],  # Default text size in mm
+    "pin_length": 2.54,  # Default pin length in mm
+}
+
+# Predefined component library mappings for quick circuit creation
+# Maps common component types to their KiCad library and symbol names
+# Organized by functional categories: basic, power, connectors
+COMMON_LIBRARIES = {
+    "basic": {
+        "resistor": {"library": "Device", "symbol": "R"},
+        "capacitor": {"library": "Device", "symbol": "C"},
+        "inductor": {"library": "Device", "symbol": "L"},
+        "led": {"library": "Device", "symbol": "LED"},
+        "diode": {"library": "Device", "symbol": "D"},
+    },
+    "power": {
+        "vcc": {"library": "power", "symbol": "VCC"},
+        "gnd": {"library": "power", "symbol": "GND"},
+        "+5v": {"library": "power", "symbol": "+5V"},
+        "+3v3": {"library": "power", "symbol": "+3V3"},
+        "+12v": {"library": "power", "symbol": "+12V"},
+        "-12v": {"library": "power", "symbol": "-12V"},
+    },
+    "connectors": {
+        "conn_2pin": {"library": "Connector", "symbol": "Conn_01x02_Male"},
+        "conn_4pin": {"library": "Connector_Generic", "symbol": "Conn_01x04"},
+        "conn_8pin": {"library": "Connector_Generic", "symbol": "Conn_01x08"},
+    },
+}
+
+# Suggested footprints for common components, ordered by preference
+# SMD variants listed first, followed by through-hole alternatives
+DEFAULT_FOOTPRINTS = {
+    "R": [
+        "Resistor_SMD:R_0805_2012Metric",
+        "Resistor_SMD:R_0603_1608Metric",
+        "Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P10.16mm_Horizontal",
+    ],
+    "C": [
+        "Capacitor_SMD:C_0805_2012Metric",
+        "Capacitor_SMD:C_0603_1608Metric",
+        "Capacitor_THT:C_Disc_D5.0mm_W2.5mm_P5.00mm",
+    ],
+    "LED": ["LED_SMD:LED_0805_2012Metric", "LED_THT:LED_D5.0mm"],
+    "D": ["Diode_SMD:D_SOD-123", "Diode_THT:D_DO-35_SOD27_P7.62mm_Horizontal"],
+}
+
+# Operation timeout values in seconds for external process management
+# Prevents hanging operations and provides user feedback
+TIMEOUT_CONSTANTS = {
+    "kicad_cli_version_check": 10.0,  # Timeout for KiCad CLI version checks
+    "kicad_cli_export": 30.0,  # Timeout for KiCad CLI export operations
+    "application_open": 10.0,  # Timeout for opening applications (e.g., KiCad)
+    "subprocess_default": 30.0,  # Default timeout for subprocess operations
+}
+
+# Progress percentage milestones for long-running operations
+# Provides consistent progress reporting across different tools
+PROGRESS_CONSTANTS = {
+    "start": 10,  # Initial progress percentage
+    "detection": 20,  # Progress after CLI detection
+    "setup": 30,  # Progress after setup complete
+    "processing": 50,  # Progress during processing
+    "finishing": 70,  # Progress when finishing up
+    "validation": 90,  # Progress during validation
+    "complete": 100,  # Progress when complete
+}
+
+# User interface display configuration values
+# Controls how much information is shown in previews and summaries
+DISPLAY_CONSTANTS = {
+    "bom_preview_limit": 20,  # Maximum number of BOM items to show in preview
+}
+
+# KiCad version string — fallback used when KICAD_VERSION env var is not set
+KICAD_VERSION = "9.0"
+
+class LibraryPathConfig:
+    """
+    KiCad symbol library path configuration.
+
+    Reads KICAD_VERSION and each path from the corresponding environment
+    variable; if a variable is absent the built-in default is used. The
+    resolved values are collected into ``self._env_vars`` so they can be
+    injected into subprocess environments that expand ``${VAR}`` URI
+    references.
+    """
+
+    @staticmethod
+    def _default_symbol_dir(kicad_app_path: str) -> str:
+        """Return the platform-specific default KiCad system symbols directory."""
+        if system == "Darwin":
+            return os.path.join(kicad_app_path, "Contents", "SharedSupport", "symbols")
+        elif system == "Windows":
+            return os.path.join(kicad_app_path, "share", "kicad", "symbols")
+        else:
+            return os.path.join(kicad_app_path, "symbols")
+
+    @staticmethod
+    def _default_footprint_dir(kicad_app_path: str) -> str:
+        """Return the platform-specific default KiCad system footprints directory."""
+        if system == "Darwin":
+            return os.path.join(kicad_app_path, "Contents", "SharedSupport", "footprints")
+        elif system == "Windows":
+            return os.path.join(kicad_app_path, "share", "kicad", "footprints")
+        else:
+            return os.path.join(kicad_app_path, "footprints")
+
+    @staticmethod
+    def _default_config_dir(kicad_version: str) -> str:
+        """Return the platform-specific default KiCad configuration directory."""
+        if system == "Darwin":
+            return os.path.expanduser(f"~/Library/Preferences/kicad/{kicad_version}")
+        elif system == "Windows":
+            appdata = os.environ.get("APPDATA", os.path.expanduser("~"))
+            return os.path.join(appdata, "kicad", kicad_version)
+        else:
+            return os.path.expanduser(f"~/.config/kicad/{kicad_version}")
+
+    @staticmethod
+    def _default_3rd_party(kicad_version: str) -> str:
+        """Return the platform-specific default KiCad 3rd-party packages directory."""
+        if system == "Darwin":
+            return os.path.expanduser(f"~/Library/Application Support/kicad/{kicad_version}/3rdparty")
+        elif system == "Windows":
+            appdata = os.environ.get("APPDATA", os.path.expanduser("~"))
+            return os.path.join(appdata, "kicad", kicad_version, "3rdparty")
+        else:
+            return os.path.expanduser(f"~/.local/share/kicad/{kicad_version}/3rdparty")
+
+    @staticmethod
+    def _default_template_dir(kicad_app_path: str, kicad_version: str) -> str:
+        """Return the platform-specific default KiCad templates directory."""
+        if system == "Darwin":
+            return os.path.join(kicad_app_path, "Contents", "SharedSupport", "template")
+        elif system == "Windows":
+            return os.path.join(kicad_app_path, "share", "kicad", "template")
+        else:
+            return os.path.join(kicad_app_path, "template")
+
+    def __init__(self):
+        kicad_version = os.environ.get("KICAD_VERSION") or KICAD_VERSION
+        _ver_tag = kicad_version.split(".")[0]
+
+        # KICAD_APP_PATH must be set in the environment (typically via .env)
+        # for AppImage / non-standard installs.  If the resolved path doesn't
+        # exist we log a clear warning rather than silently falling back —
+        # otherwise sym/fp-lib-table entries that reference
+        # ${KICAD{N}_TEMPLATE_DIR}/... etc. would be silently dropped.
+        kicad_app_path = os.environ.get("KICAD_APP_PATH") or KICAD_APP_PATH
+        if not os.path.isdir(kicad_app_path):
+            log.warning(
+                "KiCad application path does not exist: %s. "
+                "System symbol/footprint/template libraries will be unresolvable. "
+                "Set KICAD_APP_PATH in your .env file (e.g. for an AppImage, "
+                "the path under /tmp/.mount_kicad*/share/kicad while KiCad is "
+                "running).",
+                kicad_app_path,
+            )
+
+        self._kicad_config_dir = os.path.expanduser(
+            os.environ.get("KICAD_CONFIG_DIR")
+            or self._default_config_dir(kicad_version)
+        )
+        self._kicad_symbol_dir = os.path.expanduser(
+            os.environ.get("KICAD_SYMBOL_DIR")
+            or self._default_symbol_dir(kicad_app_path)
+        )
+        self._kicad_footprint_dir = os.path.expanduser(
+            os.environ.get("KICAD_FOOTPRINT_DIR")
+            or self._default_footprint_dir(kicad_app_path)
+        )
+        self._kicad_3rd_party = os.path.expanduser(
+            os.environ.get("KICAD_3RD_PARTY")
+            or self._default_3rd_party(kicad_version)
+        )
+        self._kicad_template_dir = os.path.expanduser(
+            os.environ.get("KICAD_TEMPLATE_DIR")
+            or self._default_template_dir(kicad_app_path, kicad_version)
+        )
+
+        # Env vars to inject into subprocesses that expand ${VAR} placeholders in library URIs
+        self._env_vars = {
+            f"KICAD{_ver_tag}_SYMBOL_DIR": self._kicad_symbol_dir,
+            f"KICAD{_ver_tag}_FOOTPRINT_DIR": self._kicad_footprint_dir,
+            f"KICAD{_ver_tag}_3RD_PARTY": self._kicad_3rd_party,
+            f"KICAD{_ver_tag}_TEMPLATE_DIR": self._kicad_template_dir,
+        }
+
+    @property
+    def symbol_table_file(self) -> str:
+        """Path to the sym-lib-table file."""
+        return self._kicad_config_dir + "/sym-lib-table"
+
+    def get_env_vars(self):
+        """Get the complete environment variables dictionary."""
+        return self._env_vars.copy()

kcaa/context.py

@@ -0,0 +1,85 @@
+"""
+Lifespan context management for KiCad MCP Server.
+"""
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import AsyncIterator, Dict, Any
+import logging # Import logging
+import os # Added for PID
+
+from fastmcp import FastMCP
+
+# Get PID for logging
+# _PID = os.getpid()
+
+@dataclass
+class KiCadAppContext:
+    """Type-safe context for KiCad MCP server."""
+    kicad_modules_available: bool
+    
+    # Optional cache for expensive operations
+    cache: Dict[str, Any]
+
+@asynccontextmanager
+async def kicad_lifespan(server: FastMCP, kicad_modules_available: bool = False) -> AsyncIterator[KiCadAppContext]:
+    """Manage KiCad MCP server lifecycle with type-safe context.
+    
+    This function handles:
+    1. Initializing shared resources when the server starts
+    2. Providing a typed context object to all request handlers
+    3. Properly cleaning up resources when the server shuts down
+    
+    Args:
+        server: The FastMCP server instance
+        kicad_modules_available: Flag indicating if Python modules were found (passed from create_server)
+        
+    Yields:
+        KiCadAppContext: A typed context object shared across all handlers
+    """
+    logging.info(f"Starting KiCad MCP server initialization")
+    
+    # Resources initialization - Python path setup removed
+    # print("Setting up KiCad Python modules")
+    # kicad_modules_available = setup_kicad_python_path() # Now passed as arg
+    logging.info(f"KiCad Python module availability: {kicad_modules_available} (Setup logic removed)")
+    
+    # Create in-memory cache for expensive operations
+    cache: Dict[str, Any] = {}
+    
+    # Initialize any other resources that need cleanup later
+    created_temp_dirs = [] # Assuming this is managed elsewhere or not needed for now
+    
+    try:
+        # --- Removed Python module preloading section --- 
+        # if kicad_modules_available:
+        #     try:
+        #         print("Preloading KiCad Python modules")
+        #         ...
+        #     except ImportError as e:
+        #         print(f"Failed to preload some KiCad modules: {str(e)}")
+
+        # Yield the context to the server - server runs during this time
+        logging.info(f"KiCad MCP server initialization complete")
+        yield KiCadAppContext(
+            kicad_modules_available=kicad_modules_available, # Pass the flag through
+            cache=cache
+        )
+    finally:
+        # Clean up resources when server shuts down
+        logging.info(f"Shutting down KiCad MCP server")
+        
+        # Clear the cache
+        if cache:
+            logging.info(f"Clearing cache with {len(cache)} entries")
+            cache.clear()
+        
+        # Clean up any temporary directories
+        import shutil
+        for temp_dir in created_temp_dirs:
+            try:
+                logging.info(f"Removing temporary directory: {temp_dir}")
+                shutil.rmtree(temp_dir, ignore_errors=True)
+            except Exception as e:
+                logging.error(f"Error cleaning up temporary directory {temp_dir}: {str(e)}")
+        
+        logging.info(f"KiCad MCP server shutdown complete")

kcaa/prompts/__init__.py

@@ -0,0 +1,3 @@
+"""
+Prompt templates for KiCad MCP Server.
+"""

kcaa/prompts/bom_prompts.py

@@ -0,0 +1,117 @@
+"""
+BOM-related prompt templates for KiCad.
+"""
+from fastmcp import FastMCP
+
+
+def register_bom_prompts(mcp: FastMCP) -> None:
+    """Register BOM-related prompt templates with the MCP server.
+    
+    Args:
+        mcp: The FastMCP server instance
+    """
+    
+    @mcp.prompt()
+    def analyze_components() -> str:
+        """Prompt for analyzing a KiCad project's components."""
+        prompt = """
+        I'd like to analyze the components used in my KiCad PCB design. Can you help me with:
+
+        1. Identifying all the components in my design
+        2. Analyzing the distribution of component types
+        3. Checking for any potential issues or opportunities for optimization
+        4. Suggesting any alternatives for hard-to-find or expensive components
+
+        My KiCad project is located at:
+        [Enter the full path to your .kicad_pro file here]
+
+        Please use the BOM analysis tools to help me understand my component usage.
+        """
+        
+        return prompt
+
+    @mcp.prompt()
+    def cost_estimation() -> str:
+        """Prompt for estimating project costs based on BOM."""
+        prompt = """
+        I need to estimate the cost of my KiCad PCB project for:
+        
+        1. A prototype run (1-5 boards)
+        2. A small production run (10-100 boards)
+        3. Larger scale production (500+ boards)
+        
+        My KiCad project is located at:
+        [Enter the full path to your .kicad_pro file here]
+        
+        Please analyze my BOM to help estimate component costs, and provide guidance on:
+        
+        - Which components contribute most to the overall cost
+        - Where I might find cost savings
+        - Potential volume discounts for larger runs
+        - Suggestions for alternative components that could reduce costs
+        - Estimated PCB fabrication costs based on board size and complexity
+        
+        If my BOM doesn't include cost data, please suggest how I might find pricing information for my components.
+        """
+        
+        return prompt
+
+    @mcp.prompt()
+    def bom_export_help() -> str:
+        """Prompt for assistance with exporting BOMs from KiCad."""
+        prompt = """
+        I need help exporting a Bill of Materials (BOM) from my KiCad project. I'm interested in:
+        
+        1. Understanding the different BOM export options in KiCad
+        2. Exporting a BOM with specific fields (reference, value, footprint, etc.)
+        3. Generating a BOM in a format compatible with my preferred supplier
+        4. Adding custom fields to my components that will appear in the BOM
+        
+        My KiCad project is located at:
+        [Enter the full path to your .kicad_pro file here]
+        
+        Please guide me through the process of creating a well-structured BOM for my project.
+        """
+        
+        return prompt
+
+    @mcp.prompt()
+    def component_sourcing() -> str:
+        """Prompt for help with component sourcing."""
+        prompt = """
+        I need help sourcing components for my KiCad PCB project. Specifically, I need assistance with:
+        
+        1. Identifying reliable suppliers for my components
+        2. Finding alternatives for any hard-to-find or obsolete parts
+        3. Understanding lead times and availability constraints
+        4. Balancing cost versus quality considerations
+        
+        My KiCad project is located at:
+        [Enter the full path to your .kicad_pro file here]
+        
+        Please analyze my BOM and provide guidance on sourcing these components efficiently.
+        """
+        
+        return prompt
+
+    @mcp.prompt()
+    def bom_comparison() -> str:
+        """Prompt for comparing BOMs between two design revisions."""
+        prompt = """
+        I have two versions of a KiCad project and I'd like to compare the changes between their Bills of Materials. I need to understand:
+        
+        1. Which components were added or removed
+        2. Which component values or footprints changed
+        3. The impact of these changes on the overall design
+        4. Any potential issues introduced by these changes
+        
+        My original KiCad project is located at:
+        [Enter the full path to your first .kicad_pro file here]
+        
+        My revised KiCad project is located at:
+        [Enter the full path to your second .kicad_pro file here]
+        
+        Please analyze the BOMs from both projects and help me understand the differences between them.
+        """
+        
+        return prompt

kcaa/prompts/drc_prompt.py

@@ -0,0 +1,49 @@
+"""
+DRC prompt templates for KiCad PCB design.
+"""
+from fastmcp import FastMCP
+
+
+def register_drc_prompts(mcp: FastMCP) -> None:
+    """Register DRC prompt templates with the MCP server.
+    
+    Args:
+        mcp: The FastMCP server instance
+    """
+    
+    @mcp.prompt()
+    def fix_drc_violations() -> str:
+        """Prompt for assistance with fixing DRC violations."""
+        return """
+        I'm trying to fix DRC (Design Rule Check) violations in my KiCad PCB design. I need help with:
+
+        1. Understanding what these DRC errors mean
+        2. Knowing how to fix each type of violation
+        3. Best practices for preventing DRC issues in future designs
+
+        Here are the specific DRC errors I'm seeing (please list errors from your DRC report, or use the kicad://drc/path_to_project resource to see your full DRC report):
+
+        [list your DRC errors here]
+
+        Please help me understand these errors and provide step-by-step guidance on fixing them.
+        """
+
+    @mcp.prompt()
+    def custom_design_rules() -> str:
+        """Prompt for assistance with creating custom design rules."""
+        return """
+        I want to create custom design rules for my KiCad PCB. My project has the following requirements:
+
+        1. [Describe your project's specific requirements]
+        2. [List any special considerations like high voltage, high current, RF, etc.]
+        3. [Mention any manufacturing constraints]
+
+        Please help me set up appropriate design rules for my KiCad project, including:
+
+        - Minimum trace width and clearance settings
+        - Via size and drill constraints
+        - Layer stack considerations
+        - Other important design rules
+
+        Explain how to configure these rules in KiCad and how to verify they're being applied correctly.
+        """