@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/tools/project.py

@@ -0,0 +1,196 @@
+"""KiCad project creation tools for KiCad MCP Server - Updated for KiCad 9.0+
+
+Uses KiCad's template projects to ensure 100% compatibility.
+"""
+
+import json
+import re
+import shutil
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+from ..server import mcp
+
+
+def _find_kicad_template() -> Path | None:
+    """Find KiCad template directory, auto-detecting installed version."""
+    from ..utils.kicad_version import find_kicad_install
+
+    kicad = find_kicad_install()
+    if kicad:
+        install_path, _version = kicad
+        for template_name in ["Arduino_Mega", "EuroCard160mmX100mm"]:
+            p = install_path / "share" / "kicad" / "template" / template_name
+            if p.exists():
+                return p
+
+    # macOS fallback
+    mac_base = Path("/Applications/KiCad/KiCad.app/Contents/SharedSupport/template")
+    for t in ["Arduino_Mega", "EuroCard160mmX100mm"]:
+        if (mac_base / t).exists():
+            return mac_base / t
+
+    # Linux fallback
+    for base in [Path("/usr/share/kicad/template"), Path("/usr/local/share/kicad/template")]:
+        for t in ["Arduino_Mega", "EuroCard160mmX100mm"]:
+            if (base / t).exists():
+                return base / t
+
+    return None
+
+
+def _get_date_string() -> str:
+    """Get current date in ISO format."""
+    return datetime.now().strftime("%Y-%m-%d")
+
+
+@mcp.tool()
+async def create_kicad_project(
+    project_path: str,
+    project_name: str,
+    title: str = "",
+    company: str = "",
+) -> str:
+    """Create a complete KiCad 9.0+ project by copying KiCad's template.
+
+    This method copies a KiCad template project and modifies it,
+    ensuring 100% compatibility with KiCad 9.0+.
+
+    Args:
+        project_path: Directory path for the project
+        project_name: Name of the project (without extension)
+        title: Optional project title
+        company: Optional company name
+
+    Returns:
+        Confirmation message with created files
+    """
+    try:
+        # Find KiCad template
+        template_path = _find_kicad_template()
+
+        if not template_path:
+            return """❌ KiCad template not found.
+
+Please ensure KiCad is installed:
+  macOS:   brew install --cask kicad
+  Linux:   sudo apt install kicad
+  Windows: https://www.kicad.org/download/
+
+After installation, this tool will use KiCad's template to create projects.
+"""
+
+        path = Path(project_path)
+        path.mkdir(parents=True, exist_ok=True)
+
+        date_str = _get_date_string()
+        title_text = title or project_name
+
+        # Copy all files from template
+        for file in template_path.glob("*"):
+            if file.is_file():
+                dest = path / file.name.replace("Arduino_Mega", project_name).replace("EuroCard160mmX100mm", project_name)
+                shutil.copy(file, dest)
+
+        # Rename files if needed
+        for old_file in path.glob("*"):
+            if "Arduino_Mega" in old_file.name or "EuroCard160mmX100mm" in old_file.name:
+                new_name = old_file.name.replace("Arduino_Mega", project_name).replace("EuroCard160mmX100mm", project_name)
+                new_path = old_file.parent / new_name
+                if old_file != new_path:
+                    old_file.rename(new_path)
+
+        # Modify .kicad_pro file
+        pro_file = path / f"{project_name}.kicad_pro"
+
+        if pro_file.exists():
+            with open(pro_file) as f:
+                pro_data = json.load(f)
+
+            # Update metadata
+            pro_data["meta"]["filename"] = f"{project_name}.kicad_pro"
+
+            # Update sheets
+            if "sheets" in pro_data and pro_data["sheets"]:
+                new_uuid = str(uuid.uuid4())
+                pro_data["sheets"] = [[new_uuid, "Root"]]
+
+            with open(pro_file, 'w') as f:
+                json.dump(pro_data, f, indent=2)
+
+        # Modify .kicad_sch file
+        sch_file = path / f"{project_name}.kicad_sch"
+
+        if sch_file.exists():
+            content = sch_file.read_text()
+
+            # Update UUID
+            new_uuid = str(uuid.uuid4())
+            content = re.sub(r'\(uuid "([^"]*)"\)', f'(uuid "{new_uuid}")', content, count=1)
+
+            # Update title block. Templates may not contain (title "...") or
+            # (company "...") fields, so insert them into (title_block ...) when
+            # absent — otherwise the regex silently no-ops while the success
+            # message still claims the title/company was written.
+            if title_text:
+                if '(title "' in content:
+                    content = re.sub(r'\(title "([^"]*)"\)', f'(title "{title_text}")', content, count=1)
+                else:
+                    content = content.replace("(title_block", f'(title_block\n    (title "{title_text}")', 1)
+            if '(date "' in content:
+                content = re.sub(r'\(date "([^"]*)"\)', f'(date "{date_str}")', content, count=1)
+            if company:
+                if '(company "' in content:
+                    content = re.sub(r'\(company "([^"]*)"\)', f'(company "{company}")', content, count=1)
+                else:
+                    content = content.replace("(title_block", f'(title_block\n    (company "{company}")', 1)
+
+            sch_file.write_text(content)
+
+        # List files that were actually copied (templates vary — don't hardcode
+        # "fp-lib-table", which some templates don't ship).
+        created_files = sorted(p.name for p in path.iterdir() if p.is_file())
+        files_listing = "\n".join(f"- {n}" for n in created_files)
+
+        return f"""# ✅ KiCad 9.0+ Project Created Successfully!
+
+**Project Path:** {path}
+**Project Name:** {project_name}
+**Title:** {title_text}
+**Company:** {company or '(none)'}
+**Template Used:** {template_path.name}
+
+## 📄 Files Created:
+
+{files_listing}
+
+## 📖 How to Open in KiCad 9.0+:
+
+1. Open KiCad
+2. File → Open Project...
+3. Navigate to: {pro_file}
+4. Click Open
+
+The project will open in KiCad 9.0+ **without** version warnings!
+
+## ✅ Compatibility:
+
+- Created from KiCad's official template
+- 100% compatible with KiCad 9.0+
+- All settings and configurations are valid
+- Ready for schematic design and PCB layout
+
+## 🔧 Next Steps:
+
+1. Open schematic editor to add components
+2. Use `add_component_from_library` to add parts
+3. Use `add_wire` and `add_global_label` for connections
+4. Update PCB from schematic when ready
+
+Project is ready for KiCad 9.0+! 🚀
+"""
+
+    except Exception as e:
+        import traceback
+        return f"Error creating project: {e}\n\n{traceback.format_exc()}"

package/mcp_servers/kicad-mcp-server/src/kicad_mcp_server/tools/schematic.py

@@ -0,0 +1,319 @@
+"""Schematic analysis tools for KiCad MCP Server."""
+
+from pathlib import Path
+
+from ..parsers.schematic_parser import SchematicParser
+from ..server import mcp
+
+
+@mcp.tool()
+async def list_schematic_components(
+    file_path: str,
+    filter_type: str | None = None,
+    filter_value: str | None = None,
+    filter_dnp: bool | None = None,
+) -> str:
+    """List all components in a KiCad schematic file.
+
+    Args:
+        file_path: Path to .kicad_sch file
+        filter_type: Optional filter by component type prefix (e.g., 'R', 'C', 'U', 'IC')
+        filter_value: Optional filter by component value (partial match)
+        filter_dnp: Optional filter by DNP flag (True=only DNP, False=only non-DNP)
+
+    Returns:
+        Formatted list of components with their properties
+    """
+    try:
+        parser = SchematicParser(file_path)
+        components = parser.get_components()
+
+        # Apply filters
+        if filter_type:
+            components = [c for c in components if c.reference.startswith(filter_type.upper())]
+
+        if filter_value:
+            components = [c for c in components if filter_value.lower() in c.value.lower()]
+
+        if filter_dnp is not None:
+            components = [c for c in components if c.flags.get("dnp", False) == filter_dnp]
+
+        if not components:
+            return "No components found matching the specified criteria."
+
+        # Check if any non-default flags exist
+        has_dnp = any(c.flags.get("dnp", False) for c in components)
+        has_not_in_bom = any(not c.flags.get("in_bom", True) for c in components)
+
+        # Format output
+        header = "| Reference | Value | Footprint | Library |"
+        separator = "|-----------|-------|-----------|---------|"
+        if has_dnp or has_not_in_bom:
+            header += " DNP | In BOM |"
+            separator += "-----|--------|"
+
+        lines = [
+            f"# Components in {file_path}",
+            f"Total: {len(components)} component(s)",
+            "",
+            header,
+            separator,
+        ]
+
+        for comp in components:
+            footprint = comp.footprint or "-"
+            library = comp.library_id.split(":")[-1] if ":" in comp.library_id else comp.library_id
+            row = f"| {comp.reference} | {comp.value} | {footprint} | {library} |"
+            if has_dnp or has_not_in_bom:
+                dnp = "Yes" if comp.flags.get("dnp", False) else ""
+                in_bom = "No" if not comp.flags.get("in_bom", True) else ""
+                row += f" {dnp} | {in_bom} |"
+            lines.append(row)
+
+        return "\n".join(lines)
+
+    except FileNotFoundError as e:
+        return f"Error: {e}"
+    except Exception as e:
+        return f"Error parsing schematic: {e}"
+
+
+@mcp.tool()
+async def get_symbol_details(file_path: str, reference: str) -> str:
+    """Get detailed information about a specific symbol/component.
+
+    Args:
+        file_path: Path to .kicad_sch file
+        reference: Component reference designator (e.g., 'R1', 'U1')
+
+    Returns:
+        Detailed component information including pins and properties
+    """
+    try:
+        parser = SchematicParser(file_path)
+        component = parser.get_component_by_reference(reference)
+
+        if not component:
+            return f"Component '{reference}' not found in schematic."
+
+        # Format output
+        lines = [
+            f"# Symbol Details: {component.reference}",
+            "",
+            f"**Value:** {component.value}",
+            f"**Library:** {component.library_id}",
+            f"**Footprint:** {component.footprint or 'Not assigned'}",
+            f"**Position:** ({component.position[0]:.2f}, {component.position[1]:.2f})",
+        ]
+
+        if component.unit:
+            lines.append(f"**Unit:** {component.unit}")
+
+        # Properties
+        if component.properties:
+            lines.append("")
+            lines.append("## Properties")
+            for key, value in sorted(component.properties.items()):
+                if key not in ("Value", "Footprint"):
+                    lines.append(f"- {key}: {value}")
+
+        # Pins
+        if component.pins:
+            lines.append("")
+            lines.append("## Pins")
+            lines.append("| Pin | Name | Type |")
+            lines.append("|-----|------|------|")
+            for pin in component.pins:
+                pin_num = pin.get("number", "?")
+                pin_name = pin.get("name", "")
+                pin_type = pin.get("electrical_type", "")
+                lines.append(f"| {pin_num} | {pin_name} | {pin_type} |")
+
+        return "\n".join(lines)
+
+    except FileNotFoundError as e:
+        return f"Error: {e}"
+    except Exception as e:
+        return f"Error parsing schematic: {e}"
+
+
+@mcp.tool()
+async def search_symbols(
+    file_path: str,
+    pattern: str,
+    search_fields: str = "all",
+) -> str:
+    """Search for symbols/components matching a pattern.
+
+    Args:
+        file_path: Path to .kicad_sch file
+        pattern: Search pattern (supports regex)
+        search_fields: Fields to search: 'all', 'reference', 'value', 'library'
+
+    Returns:
+        List of matching components
+    """
+    try:
+        parser = SchematicParser(file_path)
+        components = parser.search_components(pattern)
+
+        if not components:
+            return f"No components found matching pattern: {pattern}"
+
+        # Format output
+        lines = [
+            f"# Search Results: '{pattern}'",
+            f"Found {len(components)} matching component(s)",
+            "",
+            "| Reference | Value | Library |",
+            "|-----------|-------|---------|",
+        ]
+
+        for comp in components[:50]:  # Limit to 50 results
+            library = comp.library_id.split(":")[-1] if ":" in comp.library_id else comp.library_id
+            lines.append(f"| {comp.reference} | {comp.value} | {library} |")
+
+        if len(components) > 50:
+            lines.append(f"\n... and {len(components) - 50} more")
+
+        return "\n".join(lines)
+
+    except FileNotFoundError as e:
+        return f"Error: {e}"
+    except Exception as e:
+        return f"Error parsing schematic: {e}"
+
+
+@mcp.tool()
+async def list_schematic_nets(
+    file_path: str,
+    filter_power: bool = False,
+) -> str:
+    """List all nets in a KiCad schematic.
+
+    Args:
+        file_path: Path to .kicad_sch file
+        filter_power: If True, only show power nets (VCC, GND, etc.)
+
+    Returns:
+        Formatted list of nets
+    """
+    try:
+        parser = SchematicParser(file_path)
+        nets = parser.get_nets()
+
+        # Filter for power nets if requested
+        if filter_power:
+            power_keywords = ["gnd", "vcc", "vdd", "vss", "+", "-"]
+            nets = [n for n in nets if any(kw in n.name.lower() for kw in power_keywords)]
+
+        # Sub-sheet detection: unnamed nets can't be resolved without hierarchy
+        from .netlist import _find_root_schematic
+
+        sch_path = Path(file_path)
+        root_sch = _find_root_schematic(sch_path)
+        subsheet_note = ""
+        if root_sch:
+            subsheet_note = (
+                f"**Note:** `{sch_path.name}` is a sub-sheet. "
+                f"Unnamed wire-only nets cannot be resolved without the full "
+                f"hierarchy context and will not appear here. "
+                f"Use `generate_netlist` on the root schematic `{root_sch.name}` "
+                f"for complete net data."
+            )
+
+        if not nets:
+            if subsheet_note:
+                return f"No nets found.\n\n{subsheet_note}"
+            return "No nets found."
+
+        # Format output
+        lines = [
+            f"# Nets in {file_path}",
+            f"Total: {len(nets)} net(s)",
+            "",
+            "| Net Name | Type | Code |",
+            "|----------|------|------|",
+        ]
+
+        for net in sorted(nets, key=lambda n: n.name):
+            lines.append(f"| {net.name} | {net.type} | {net.code} |")
+
+        if subsheet_note:
+            lines.append("")
+            lines.append(subsheet_note)
+
+        return "\n".join(lines)
+
+    except FileNotFoundError as e:
+        return f"Error: {e}"
+    except Exception as e:
+        return f"Error parsing schematic: {e}"
+
+
+@mcp.tool()
+async def get_schematic_info(file_path: str) -> str:
+    """Get general information about a schematic file.
+
+    Args:
+        file_path: Path to .kicad_sch file
+
+    Returns:
+        Schematic metadata and statistics
+    """
+    try:
+        parser = SchematicParser(file_path)
+        title_block = parser.get_title_block()
+        components = parser.get_components()
+        nets = parser.get_nets()
+        sheets = parser.get_sheets()
+
+        # Count components by type
+        component_counts = {}
+        for comp in components:
+            prefix = "".join(c for c in comp.reference if c.isalpha())
+            component_counts[prefix] = component_counts.get(prefix, 0) + 1
+
+        # Format output
+        lines = [
+            f"# Schematic Information: {file_path}",
+            "",
+            "## Project Information",
+        ]
+
+        if title_block.get("title"):
+            lines.append(f"**Title:** {title_block['title']}")
+        if title_block.get("company"):
+            lines.append(f"**Company:** {title_block['company']}")
+        if title_block.get("date"):
+            lines.append(f"**Date:** {title_block['date']}")
+        if title_block.get("rev"):
+            lines.append(f"**Revision:** {title_block['rev']}")
+
+        lines.extend([
+            "",
+            "## Statistics",
+            f"**Total Components:** {len(components)}",
+            f"**Total Nets:** {len(nets)}",
+            f"**Hierarchical Sheets:** {len(sheets)}",
+            "",
+            "## Components by Type",
+])
+
+        for prefix in sorted(component_counts.keys()):
+            lines.append(f"- {prefix}: {component_counts[prefix]}")
+
+        if sheets:
+            lines.extend([
+                "",
+                "## Hierarchical Sheets",
+            ])
+            for sheet in sheets:
+                lines.append(f"- {sheet['name']}: {sheet['file']}")
+
+        return "\n".join(lines)
+
+    except FileNotFoundError as e:
+        return f"Error: {e}"
+    except Exception as e:
+        return f"Error parsing schematic: {e}"