@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/parsers/netlist_parser.py

@@ -0,0 +1,234 @@
+"""KiCad netlist parser for accurate component network tracking."""
+
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class NetlistComponent:
+    """Component from netlist file."""
+
+    reference: str
+    value: str
+    library: str
+    footprint: str | None = None
+    pins: dict[str, str] = field(default_factory=dict)  # pin_number -> net_name
+
+
+@dataclass
+class NetlistNet:
+    """Net from netlist file."""
+
+    name: str
+    code: int
+    pins: list[tuple[str, str]] = field(default_factory=list)  # (reference, pin_number)
+
+
+class NetlistParser:
+    """Parser for KiCad netlist files (.xml)."""
+
+    def __init__(self, file_path: str) -> None:
+        """Initialize parser with netlist file.
+
+        Args:
+            file_path: Path to .xml netlist file
+
+        Raises:
+            FileNotFoundError: If file doesn't exist
+            ValueError: If file is not a .xml file
+        """
+        self.file_path = Path(file_path)
+        if not self.file_path.exists():
+            raise FileNotFoundError(f"Netlist file not found: {file_path}")
+
+        if self.file_path.suffix != ".xml":
+            raise ValueError(f"Netlist file must be .xml, got: {self.file_path.suffix}")
+
+        self._data: dict[str, Any] | None = None
+
+    def _parse_file(self) -> dict[str, Any]:
+        """Parse the netlist XML file.
+
+        Returns:
+            Parsed data structure
+        """
+        if self._data is not None:
+            return self._data
+
+        tree = ET.parse(self.file_path)
+        root = tree.getroot()
+
+        # Parse components (KiCad 9.0+ uses <comp> not <component>)
+        components = {}
+        for comp in root.findall(".//comp"):
+            ref = comp.get("ref")
+            value = comp.findtext("value", "")
+            # KiCad XML: footprint is a direct <footprint>Lib:Footprint</footprint>
+            # element (NOT footprint/libpart), and libsource is an attribute-only
+            # element <libsource lib="..." part="..."/> (NOT libsource/libpart).
+            footprint = comp.findtext("footprint") or ""
+            libsource = comp.find("libsource")
+            library = libsource.get("lib", "") if libsource is not None else ""
+
+            # Pins will be populated from nets later
+            components[ref] = NetlistComponent(
+                reference=ref,
+                value=value,
+                library=library,
+                footprint=footprint,
+                pins={},  # Empty initially, will populate from nets
+            )
+
+        # Parse nets and populate component pins
+        nets = {}
+        for net in root.findall(".//net"):
+            code_attr = net.get("code")
+            code = int(code_attr) if code_attr and code_attr.lstrip("-").isdigit() else -1
+            name = net.get("name")
+
+            pins_list = []
+            for node in net.findall("node"):
+                ref = node.get("ref")
+                pin_num = node.get("pin")
+                if ref and pin_num:
+                    pins_list.append((ref, pin_num))
+
+                    # Populate component pins
+                    if ref in components:
+                        components[ref].pins[pin_num] = name
+
+            nets[name] = NetlistNet(name=name, code=code, pins=pins_list)
+
+        self._data = {
+            "components": components,
+            "nets": nets,
+        }
+
+        return self._data
+
+    def _get_net_name(self, root: ET.Element, net_code: str) -> str:
+        """Get net name from net code.
+
+        Args:
+            root: XML root element
+            net_code: Net code string (e.g., "3")
+
+        Returns:
+            Net name
+        """
+        net_elem = root.find(f".//net[@code='{net_code}']")
+        if net_elem is not None:
+            return net_elem.get("name", f"net_{net_code}")
+        return f"net_{net_code}"
+
+    def get_components(self) -> dict[str, NetlistComponent]:
+        """Get all components from netlist.
+
+        Returns:
+            Dictionary mapping reference to component
+        """
+        data = self._parse_file()
+        return data["components"]
+
+    def get_nets(self) -> dict[str, NetlistNet]:
+        """Get all nets from netlist.
+
+        Returns:
+            Dictionary mapping net name to net
+        """
+        data = self._parse_file()
+        return data["nets"]
+
+    def get_component_nets(self, reference: str) -> dict[str, list[str]]:
+        """Get all networks for a component.
+
+        Args:
+            reference: Component reference (e.g., "R16")
+
+        Returns:
+            Dictionary mapping net name to list of connected pins
+        """
+        components = self.get_components()
+        if reference not in components:
+            return {}
+
+        comp = components[reference]
+        net_pins = {}
+
+        for pin_num, net_name in comp.pins.items():
+            if net_name not in net_pins:
+                net_pins[net_name] = []
+            net_pins[net_name].append(pin_num)
+
+        return net_pins
+
+    def get_net_components(self, net_name: str) -> list[tuple[str, str]]:
+        """Get all components connected to a net.
+
+        Args:
+            net_name: Net name (e.g., "PMIC_I2C_SCL")
+
+        Returns:
+            List of (reference, pin_number) tuples
+        """
+        nets = self.get_nets()
+        if net_name not in nets:
+            return []
+
+        return nets[net_name].pins
+
+    def trace_connection(self, reference: str, pin_number: str | None = None) -> dict[str, Any]:
+        """Trace connections from a component pin.
+
+        Args:
+            reference: Component reference
+            pin_number: Optional pin number (if None, trace all pins)
+
+        Returns:
+            Connection information
+        """
+        components = self.get_components()
+        if reference not in components:
+            return {"error": f"Component {reference} not found in netlist"}
+
+        comp = components[reference]
+
+        if pin_number:
+            # Trace specific pin
+            if pin_number not in comp.pins:
+                return {"error": f"Pin {pin_number} not found in component {reference}"}
+
+            net_name = comp.pins[pin_number]
+            nets = self.get_nets()
+            connected = nets[net_name].pins if net_name in nets else []
+
+            return {
+                "component": reference,
+                "pin": pin_number,
+                "net": net_name,
+                "connected_to": [(ref, pin) for ref, pin in connected if ref != reference],
+            }
+
+        else:
+            # Trace all pins. A component can have several pins on the same net
+            # (relay contacts, multiple GND pins), so group as a list per net
+            # instead of overwriting earlier pins.
+            net_connections: dict[str, list[dict[str, Any]]] = {}
+            for pin_num, net_name in comp.pins.items():
+                nets = self.get_nets()
+                connected = nets[net_name].pins if net_name in nets else []
+                net_connections.setdefault(net_name, []).append(
+                    {
+                        "pin": pin_num,
+                        "connected_to": [
+                            (ref, pin) for ref, pin in connected if ref != reference
+                        ],
+                    }
+                )
+
+            return {
+                "component": reference,
+                "nets": net_connections,
+            }

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/parsers/pcb_parser.py

@@ -0,0 +1,375 @@
+"""PCB file parser wrapper using kicad-skip."""
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from ..utils.file_handlers import validate_kicad_file
+
+
+@dataclass
+class PCBFootprint:
+    """Footprint from PCB file."""
+
+    reference: str
+    footprint_id: str
+    value: str
+    layer: str = "F.Cu"
+    position: tuple[float, float] = (0.0, 0.0)
+    rotation: float = 0.0
+    pad_count: int = 0
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "PCBFootprint":
+        """Create from parsed data structure."""
+        at = data.get("at", {})
+        position = (float(at.get("x", 0)), float(at.get("y", 0)))
+        rotation = float(at.get("rotation", 0))
+
+        return cls(
+            reference=data.get("reference", ""),
+            footprint_id=data.get("footprint_id", ""),
+            value=data.get("value", ""),
+            layer=data.get("layer", "F.Cu"),
+            position=position,
+            rotation=rotation,
+            pad_count=len(data.get("pads", [])),
+        )
+
+
+def _read_file_with_encoding_fallback(file_path: Path) -> str:
+    """Read file with multiple encoding fallback support.
+
+    Args:
+        file_path: Path to the file to read
+
+    Returns:
+        File content as string
+
+    Note:
+        Tries multiple encodings to handle different KiCad file formats
+        and potential encoding issues.
+    """
+    encodings = ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']
+    content = None
+
+    for encoding in encodings:
+        try:
+            content = file_path.read_text(encoding=encoding)
+            break
+        except UnicodeDecodeError:
+            continue
+
+    if content is None:
+        # Last resort: read with error handling
+        content = file_path.read_text(encoding='utf-8', errors='ignore')
+
+    return content
+
+
+class PCBParser:
+    """Parser for KiCad PCB files (.kicad_pcb)."""
+
+    def __init__(self, file_path: str) -> None:
+        """Initialize parser with PCB file.
+
+        Args:
+            file_path: Path to .kicad_pcb file
+
+        Raises:
+            FileNotFoundError: If file doesn't exist
+            ValueError: If file is not a .kicad_pcb file
+        """
+        self.file_path = validate_kicad_file(file_path, ".kicad_pcb")
+        self._data: dict[str, Any] | None = None
+
+    def _parse_file(self) -> dict[str, Any]:
+        """Parse the PCB file.
+
+        Returns:
+            Parsed data structure
+        """
+        if self._data is not None:
+            return self._data
+
+        content = _read_file_with_encoding_fallback(self.file_path)
+
+        # Extract basic information
+        self._data = {
+            "path": str(self.file_path),
+            "general": self._parse_general(content),
+            "footprints": self._parse_footprints(content),
+            "tracks": self._parse_tracks(content),
+            "vias": self._parse_vias(content),
+            "zones": self._parse_zones(content),
+            "setup": self._parse_setup(content),
+        }
+
+        return self._data
+
+    def _parse_general(self, content: str) -> dict[str, Any]:
+        """Parse general section."""
+        general = {"thickness": 1.6, "layers": 2}
+
+        # Extract thickness
+        thickness_match = re.search(r'thickness\s+([\d.]+)', content)
+        if thickness_match:
+            general["thickness"] = float(thickness_match.group(1))
+
+        # Count layers
+        layer_pattern = r'\(layer\s+"([^"]+)"'
+        layers = re.findall(layer_pattern, content)
+        # Filter for copper layers. A startswith("F."/"B.") check is wrong:
+        # F.SilkS / F.Paste / F.Mask / F.Fab / F.CrtYd / F.Adhes all start with
+        # "F." but are NOT copper. Only F.Cu, B.Cu and In<N>.Cu are copper.
+        copper_layers = [
+            layer for layer in set(layers)
+            if layer in ("F.Cu", "B.Cu") or re.match(r"In\d+\.Cu$", layer)
+        ]
+        general["layers"] = len(copper_layers) or 2
+
+        return general
+
+    def _parse_footprints(self, content: str) -> list[dict[str, Any]]:
+        """Parse footprints from PCB.
+
+        Uses multi-line regex to match KiCad footprint instances.
+        """
+        footprints = []
+
+        # Simpler pattern: Match (footprint "..." followed by (at ... sometime later)
+        # We'll find the footprint line, then search forward for the (at ...) line
+        footprint_lines_pattern = r'\(footprint\s+"([^"]+)"'
+
+        for match in re.finditer(footprint_lines_pattern, content):
+            footprint_id = match.group(1)
+            start_pos = match.start()
+
+            # Search forward for the (at ...) line, within a reasonable distance
+            search_area = content[start_pos:start_pos + 500]
+            at_match = re.search(r'\(at\s+([\d.]+)\s+([\d.]+)(?:\s+([\d.\-]+))?\)', search_area)
+
+            if at_match:
+                x = float(at_match.group(1))
+                y = float(at_match.group(2))
+                rotation = float(at_match.group(3)) if at_match.group(3) else 0.0
+
+                # Extract a larger block for reference and value
+                # Find the matching closing parenthesis for the footprint
+                depth = 0
+                found_open = False
+                end_pos = start_pos
+                block_start = start_pos
+
+                # Find where the (footprint block starts (first '(' after the keyword)
+                while end_pos < len(content) and end_pos < start_pos + 20:
+                    if content[end_pos] == '(':
+                        found_open = True
+                        block_start = end_pos
+                        break
+                    end_pos += 1
+
+                if found_open:
+                    # Now find the matching closing parenthesis
+                    depth = 1
+                    end_pos = block_start + 1
+                    while end_pos < len(content):
+                        if content[end_pos] == '(':
+                            depth += 1
+                        elif content[end_pos] == ')':
+                            depth -= 1
+                            if depth == 0:
+                                break
+                        end_pos += 1
+
+                    footprint_block = content[block_start:end_pos]
+
+                    # Extract reference: KiCad 9+ uses (property "Reference" "..."),
+                    # KiCad 4/5 used (fp_text reference "..."). Support both.
+                    ref_match = (re.search(r'\(property\s+"Reference"\s+"([^"]+)"', footprint_block)
+                                 or re.search(r'\(fp_text\s+reference\s+"([^"]+)"', footprint_block))
+                    reference = ref_match.group(1) if ref_match else ""
+
+                    # Extract value (same version split)
+                    val_match = (re.search(r'\(property\s+"Value"\s+"([^"]+)"', footprint_block)
+                                 or re.search(r'\(fp_text\s+value\s+"([^"]+)"', footprint_block))
+                    value = val_match.group(1) if val_match else ""
+
+                    # Extract layer (default to F.Cu if not found)
+                    layer_match = re.search(r'\(layer\s+"([^"]+)"', footprint_block)
+                    layer = layer_match.group(1) if layer_match else "F.Cu"
+
+                    # Count pads
+                    pad_count = len(re.findall(r'\(pad\s+', footprint_block))
+
+                    footprints.append({
+                        "footprint_id": footprint_id,
+                        "reference": reference,
+                        "value": value,
+                        "layer": layer,
+                        "at": {"x": x, "y": y, "rotation": rotation},
+                        "pads": [],
+                        "pad_count": pad_count,
+                    })
+
+        return footprints
+
+    def _parse_tracks(self, content: str) -> list[dict[str, Any]]:
+        """Parse track segments."""
+        tracks = []
+
+        # KiCad 10 format: (segment (start x y) (end x y) (width w) (layer "...") (net "name") (uuid "..."))
+        # The net field uses quoted string: (net "netname")
+        segment_pattern = (
+            r'\(segment\s+'
+            r'\(start\s+([\d.]+)\s+([\d.]+)\)\s+'
+            r'\(end\s+([\d.]+)\s+([\d.]+)\)\s+'
+            r'\(width\s+([\d.]+)\)\s+'
+            r'\(layer\s+"([^"]+)"\)\s+'
+            r'\(net\s+"([^"]*)"\)'
+        )
+
+        for match in re.finditer(segment_pattern, content):
+            x1, y1 = float(match.group(1)), float(match.group(2))
+            x2, y2 = float(match.group(3)), float(match.group(4))
+            dx, dy = x2 - x1, y2 - y1
+            tracks.append({
+                "start": {"x": x1, "y": y1},
+                "end": {"x": x2, "y": y2},
+                "width": float(match.group(5)),
+                "layer": match.group(6),
+                "net": match.group(7),
+                "length": (dx * dx + dy * dy) ** 0.5,
+            })
+
+        return tracks
+
+    def _parse_vias(self, content: str) -> list[dict[str, Any]]:
+        """Parse vias."""
+        vias = []
+
+        # KiCad 10 format: (via (at x y) (size s) (drill d) (layers "L1" "L2") (free yes) (net "name") (uuid "..."))
+        via_pattern = (
+            r'\(via\s+'
+            r'\(at\s+([\d.]+)\s+([\d.]+)\)\s+'
+            r'\(size\s+([\d.]+)\)\s+'
+            r'\(drill\s+([\d.]+)\)\s+'
+            r'\(layers\s+"([^"]+)"\s+"([^"]+)"\)\s+'
+            r'(?:\(free\s+yes\)\s+)?'
+            r'(?:\(net\s+"([^"]*)"\)\s+)?'
+        )
+
+        for match in re.finditer(via_pattern, content):
+            vias.append({
+                "at": {"x": float(match.group(1)), "y": float(match.group(2))},
+                "size": float(match.group(3)),
+                "drill": float(match.group(4)),
+                "top_layer": match.group(5),
+                "bottom_layer": match.group(6),
+                "net": match.group(7) or "",
+            })
+
+        # Fallback: simpler pattern for single-layer via or older format
+        if not vias:
+            via_pattern_simple = r'\(via\s+\(at\s+([\d.]+)\s+([\d.]+)\)\s+\(size\s+([\d.]+)\)\s+\(drill\s+([\d.]+)'
+            for match in re.finditer(via_pattern_simple, content):
+                vias.append({
+                    "at": {"x": float(match.group(1)), "y": float(match.group(2))},
+                    "size": float(match.group(3)),
+                    "drill": float(match.group(4)),
+                })
+
+        return vias
+
+    def _parse_zones(self, content: str) -> list[dict[str, Any]]:
+        """Parse copper zones."""
+        zones = []
+
+        # KiCad 10 format: (zone (net "name") (layer "...") ...)
+        zone_pattern = r'\(zone\s+\(net\s+"([^"]+)"\)\s+\(layer\s+"([^"]+)"\)'
+
+        for match in re.finditer(zone_pattern, content):
+            zones.append({
+                "net_name": match.group(1),
+                "layer": match.group(2),
+            })
+
+        # Fallback: KiCad 9 format (net code + net_name)
+        if not zones:
+            zone_pattern_v9 = r'\(zone\s+\(net\s+(\d+)\)\s*\(net_name\s+"([^"]+)"'
+            for match in re.finditer(zone_pattern_v9, content):
+                zones.append({
+                    "net_name": match.group(2),
+                    "layer": "",
+                })
+
+        return zones
+
+    def _parse_setup(self, content: str) -> dict[str, Any]:
+        """Parse setup section for design rules."""
+        setup = {
+            "trace_min": 0.2,
+            "via_min": 0.4,
+            "clearance": 0.15,
+        }
+
+        # Extract design rules
+        setup_match = re.search(
+            r'\(setup.*?\(min_resolution\s+([\d.]+)\)', content, re.DOTALL
+        )
+        if setup_match:
+            # Try to extract trace and via sizes
+            trace_match = re.search(
+                r'\(trace_min\s+([\d.]+)', content[: content.find(setup_match.group(0)) + 500]
+            )
+            if trace_match:
+                setup["trace_min"] = float(trace_match.group(1))
+
+        return setup
+
+    def get_footprints(self) -> list[PCBFootprint]:
+        """Get all footprints from PCB.
+
+        Returns:
+            List of footprints
+        """
+        data = self._parse_file()
+        return [PCBFootprint.from_dict(f) for f in data["footprints"]]
+
+    def get_statistics(self) -> dict[str, Any]:
+        """Get PCB statistics.
+
+        Returns:
+            Dictionary with statistics
+        """
+        data = self._parse_file()
+
+        # Calculate board dimensions from footprint positions
+        footprints = self.get_footprints()
+        if footprints:
+            x_coords = [f.position[0] for f in footprints]
+            y_coords = [f.position[1] for f in footprints]
+            min_x, max_x = min(x_coords), max(x_coords)
+            min_y, max_y = min(y_coords), max(y_coords)
+            # Add margin for board edge
+            margin = 5.0
+            width = max_x - min_x + (2 * margin)
+            height = max_y - min_y + (2 * margin)
+        else:
+            width = height = 0.0
+
+        # Calculate total pads from pad_count field
+        total_pads = sum(f.get("pad_count", 0) for f in data["footprints"])
+
+        return {
+            "total_footprints": len(data["footprints"]),
+            "total_pads": total_pads,
+            "total_tracks": len(data["tracks"]),
+            "total_vias": len(data["vias"]),
+            "total_zones": len(data["zones"]),
+            "board_width": width,
+            "board_height": height,
+            "layers": data["general"]["layers"],
+            "thickness": data["general"]["thickness"],
+        }