ef6c135cda
Three-phase MCP server startup: wait for Python READY handshake, send _warmup command (pcbnew.BOARD() triggers wxApp init on macOS), connect to MCP transport only after warm-up completes. Also pre-populate symbol library cache during SymbolLibraryManager init so the first search_symbols call doesn't parse 241 .kicad_sym files from disk (30-120s). Both warm-up and cache population happen before tools are registered with the MCP client. Fixes #195
6194 lines
259 KiB
Python
6194 lines
259 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
KiCAD Python Interface Script for Model Context Protocol
|
|
|
|
This script handles communication between the MCP TypeScript server
|
|
and KiCAD's Python API (pcbnew). It receives commands via stdin as
|
|
JSON and returns responses via stdout also as JSON.
|
|
"""
|
|
|
|
import hashlib
|
|
import json
|
|
import logging
|
|
import os
|
|
import shutil
|
|
import sys
|
|
import traceback
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
from typing import Any, Dict, List, Optional, Tuple
|
|
|
|
# Fix cairo DLL loading on Windows before any cairocffi import.
|
|
# cairocffi uses cffi's ffi.dlopen('cairo-2') which needs the DLL on PATH.
|
|
if sys.platform == "win32":
|
|
for _bin_dir in [
|
|
os.environ.get("PYTHONPATH", ""),
|
|
os.path.dirname(sys.executable),
|
|
r"C:\Program Files\KiCad\9.0\bin",
|
|
r"C:\Program Files\KiCad\8.0\bin",
|
|
]:
|
|
if _bin_dir and os.path.isfile(os.path.join(_bin_dir, "cairo-2.dll")):
|
|
_current_path = os.environ.get("PATH", "")
|
|
if _bin_dir not in _current_path:
|
|
os.environ["PATH"] = _bin_dir + os.pathsep + _current_path
|
|
break
|
|
|
|
import sexpdata
|
|
from annotations import AnnotationLoader
|
|
from commands.wire_manager import WireManager
|
|
from resources.resource_definitions import RESOURCE_DEFINITIONS, handle_resource_read
|
|
|
|
# Import tool schemas, resource definitions, and IPC API annotations
|
|
from schemas.tool_schemas import TOOL_SCHEMAS
|
|
|
|
_annotation_loader = AnnotationLoader()
|
|
|
|
# Configure logging
|
|
# Try to set up a file handler in ~/.kicad-mcp/logs. If that directory isn't
|
|
# writable (e.g. sandboxed test environments, restricted CI runners), fall
|
|
# back to console-only logging so importing this module never crashes.
|
|
try:
|
|
log_dir = os.path.join(os.path.expanduser("~"), ".kicad-mcp", "logs")
|
|
os.makedirs(log_dir, exist_ok=True)
|
|
log_file = os.path.join(log_dir, "kicad_interface.log")
|
|
logging.basicConfig(
|
|
level=logging.DEBUG,
|
|
format="%(asctime)s [%(levelname)s] %(message)s",
|
|
handlers=[logging.FileHandler(log_file)],
|
|
)
|
|
except (OSError, PermissionError):
|
|
logging.basicConfig(
|
|
level=logging.DEBUG,
|
|
format="%(asctime)s [%(levelname)s] %(message)s",
|
|
)
|
|
logger = logging.getLogger("kicad_interface")
|
|
|
|
# Log Python environment details
|
|
logger.info(f"Python version: {sys.version}")
|
|
logger.info(f"Python executable: {sys.executable}")
|
|
logger.info(f"Platform: {sys.platform}")
|
|
logger.info(f"Working directory: {os.getcwd()}")
|
|
|
|
# Windows-specific diagnostics
|
|
if sys.platform == "win32":
|
|
logger.info("=== Windows Environment Diagnostics ===")
|
|
logger.info(f"PYTHONPATH: {os.environ.get('PYTHONPATH', 'NOT SET')}")
|
|
logger.info(f"PATH: {os.environ.get('PATH', 'NOT SET')[:200]}...") # Truncate PATH
|
|
|
|
# Check for common KiCAD installations
|
|
common_kicad_paths = [r"C:\Program Files\KiCad", r"C:\Program Files (x86)\KiCad"]
|
|
|
|
found_kicad = False
|
|
for base_path in common_kicad_paths:
|
|
if os.path.exists(base_path):
|
|
logger.info(f"Found KiCAD installation at: {base_path}")
|
|
# List versions
|
|
try:
|
|
versions = [
|
|
d for d in os.listdir(base_path) if os.path.isdir(os.path.join(base_path, d))
|
|
]
|
|
logger.info(f" Versions found: {', '.join(versions)}")
|
|
for version in versions:
|
|
python_path = os.path.join(
|
|
base_path, version, "lib", "python3", "dist-packages"
|
|
)
|
|
if os.path.exists(python_path):
|
|
logger.info(f" ✓ Python path exists: {python_path}")
|
|
found_kicad = True
|
|
else:
|
|
logger.warning(f" ✗ Python path missing: {python_path}")
|
|
except Exception as e:
|
|
logger.warning(f" Could not list versions: {e}")
|
|
|
|
if not found_kicad:
|
|
logger.warning("No KiCAD installations found in standard locations!")
|
|
logger.warning(
|
|
"Please ensure KiCAD 9.0+ is installed from https://www.kicad.org/download/windows/"
|
|
)
|
|
|
|
logger.info("========================================")
|
|
|
|
# Add utils directory to path for imports
|
|
utils_dir = os.path.join(os.path.dirname(__file__))
|
|
if utils_dir not in sys.path:
|
|
sys.path.insert(0, utils_dir)
|
|
|
|
from utils.kicad_process import KiCADProcessManager, check_and_launch_kicad
|
|
|
|
# Import platform helper and add KiCAD paths
|
|
from utils.platform_helper import PlatformHelper
|
|
|
|
logger.info(f"Detecting KiCAD Python paths for {PlatformHelper.get_platform_name()}...")
|
|
paths_added = PlatformHelper.add_kicad_to_python_path()
|
|
|
|
if paths_added:
|
|
logger.info("Successfully added KiCAD Python paths to sys.path")
|
|
else:
|
|
logger.warning("No KiCAD Python paths found - attempting to import pcbnew from system path")
|
|
|
|
logger.info(f"Current Python path: {sys.path}")
|
|
|
|
# Check if auto-launch is enabled
|
|
AUTO_LAUNCH_KICAD = os.environ.get("KICAD_AUTO_LAUNCH", "false").lower() == "true"
|
|
if AUTO_LAUNCH_KICAD:
|
|
logger.info("KiCAD auto-launch enabled")
|
|
|
|
# Check which backend to use
|
|
# KICAD_BACKEND can be: 'auto', 'ipc', or 'swig'
|
|
KICAD_BACKEND = os.environ.get("KICAD_BACKEND", "auto").lower()
|
|
logger.info(f"KiCAD backend preference: {KICAD_BACKEND}")
|
|
|
|
# Try to use IPC backend first if available and preferred
|
|
USE_IPC_BACKEND = False
|
|
ipc_backend = None
|
|
|
|
if KICAD_BACKEND in ("auto", "ipc"):
|
|
try:
|
|
logger.info("Checking IPC backend availability...")
|
|
from kicad_api.ipc_backend import IPCBackend
|
|
|
|
# Try to connect to running KiCAD
|
|
ipc_backend = IPCBackend()
|
|
if ipc_backend.connect():
|
|
USE_IPC_BACKEND = True
|
|
logger.info(f"✓ Using IPC backend - real-time UI sync enabled!")
|
|
logger.info(f" KiCAD version: {ipc_backend.get_version()}")
|
|
else:
|
|
logger.info("IPC backend available but KiCAD not running with IPC enabled")
|
|
ipc_backend = None
|
|
except ImportError:
|
|
logger.info("IPC backend not available (kicad-python not installed)")
|
|
except Exception as e:
|
|
logger.info(f"IPC backend connection failed: {e}")
|
|
ipc_backend = None
|
|
|
|
# Fall back to SWIG backend if IPC not available
|
|
if not USE_IPC_BACKEND and KICAD_BACKEND != "ipc":
|
|
# Import KiCAD's Python API (SWIG)
|
|
try:
|
|
logger.info("Attempting to import pcbnew module (SWIG backend)...")
|
|
import pcbnew # type: ignore
|
|
|
|
logger.info(f"Successfully imported pcbnew module from: {pcbnew.__file__}")
|
|
# Deferred — GetBuildVersion() triggers 55-65 s wxApp init on macOS.
|
|
# The _warmup handler pays this cost during startup (not on first tool call).
|
|
logger.warning("Using SWIG backend - changes require manual reload in KiCAD UI")
|
|
except ImportError as e:
|
|
logger.error(f"Failed to import pcbnew module: {e}")
|
|
logger.error(f"Current sys.path: {sys.path}")
|
|
|
|
# Platform-specific help message
|
|
help_message = ""
|
|
if sys.platform == "win32":
|
|
help_message = """
|
|
Windows Troubleshooting:
|
|
1. Verify KiCAD is installed: C:\\Program Files\\KiCad\\9.0
|
|
2. Check PYTHONPATH environment variable points to:
|
|
C:\\Program Files\\KiCad\\9.0\\lib\\python3\\dist-packages
|
|
3. Test with: "C:\\Program Files\\KiCad\\9.0\\bin\\python.exe" -c "import pcbnew"
|
|
4. Log file location: %USERPROFILE%\\.kicad-mcp\\logs\\kicad_interface.log
|
|
5. Run setup-windows.ps1 for automatic configuration
|
|
"""
|
|
elif sys.platform == "darwin":
|
|
help_message = """
|
|
macOS Troubleshooting:
|
|
1. Verify KiCAD is installed: /Applications/KiCad/KiCad.app
|
|
2. Check PYTHONPATH points to KiCAD's Python packages
|
|
3. Run: python3 -c "import pcbnew" to test
|
|
"""
|
|
else: # Linux
|
|
help_message = """
|
|
Linux Troubleshooting:
|
|
1. Verify KiCAD is installed: apt list --installed | grep kicad
|
|
2. Check: /usr/lib/kicad/lib/python3/dist-packages exists
|
|
3. Test: python3 -c "import pcbnew"
|
|
"""
|
|
|
|
logger.error(help_message)
|
|
|
|
error_response = {
|
|
"success": False,
|
|
"message": "Failed to import pcbnew module - KiCAD Python API not found",
|
|
"errorDetails": f"Error: {str(e)}\n\n{help_message}\n\nPython sys.path:\n{chr(10).join(sys.path)}",
|
|
}
|
|
print(json.dumps(error_response))
|
|
sys.exit(1)
|
|
except Exception as e:
|
|
logger.error(f"Unexpected error importing pcbnew: {e}")
|
|
logger.error(traceback.format_exc())
|
|
error_response = {
|
|
"success": False,
|
|
"message": "Error importing pcbnew module",
|
|
"errorDetails": str(e),
|
|
}
|
|
print(json.dumps(error_response))
|
|
sys.exit(1)
|
|
|
|
# If IPC-only mode requested but not available, exit with error
|
|
elif KICAD_BACKEND == "ipc" and not USE_IPC_BACKEND:
|
|
error_response = {
|
|
"success": False,
|
|
"message": "IPC backend requested but not available",
|
|
"errorDetails": "KiCAD must be running with IPC API enabled. Enable at: Preferences > Plugins > Enable IPC API Server",
|
|
}
|
|
print(json.dumps(error_response))
|
|
sys.exit(1)
|
|
|
|
# Import command handlers
|
|
try:
|
|
logger.info("Importing command handlers...")
|
|
from commands.board import BoardCommands
|
|
from commands.component import ComponentCommands
|
|
from commands.component_schematic import ComponentManager
|
|
from commands.connection_schematic import ConnectionManager
|
|
from commands.datasheet_manager import DatasheetManager
|
|
from commands.design_rules import DesignRuleCommands
|
|
from commands.export import ExportCommands
|
|
from commands.footprint import FootprintCreator
|
|
from commands.freerouting import FreeroutingCommands
|
|
from commands.jlcpcb import JLCPCBClient, test_jlcpcb_connection
|
|
from commands.jlcpcb_parts import JLCPCBPartsManager
|
|
from commands.library import (
|
|
LibraryCommands,
|
|
)
|
|
from commands.library import LibraryManager as FootprintLibraryManager
|
|
from commands.library_schematic import LibraryManager as SchematicLibraryManager
|
|
from commands.library_symbol import SymbolLibraryCommands, SymbolLibraryManager
|
|
from commands.project import ProjectCommands
|
|
from commands.routing import RoutingCommands
|
|
from commands.schematic import SchematicManager
|
|
from commands.symbol_creator import SymbolCreator
|
|
|
|
logger.info("Successfully imported all command handlers")
|
|
except ImportError as e:
|
|
logger.error(f"Failed to import command handlers: {e}")
|
|
error_response = {
|
|
"success": False,
|
|
"message": "Failed to import command handlers",
|
|
"errorDetails": str(e),
|
|
}
|
|
print(json.dumps(error_response))
|
|
sys.exit(1)
|
|
|
|
|
|
class KiCADInterface:
|
|
"""Main interface class to handle KiCAD operations"""
|
|
|
|
def __init__(self) -> None:
|
|
"""Initialize the interface and command handlers"""
|
|
self.board = None
|
|
self.project_filename = None
|
|
# On-disk signature (mtime_ns, sha256_hex) of self.board's file as of
|
|
# last load or successful auto-save. Used by _auto_save_board() to
|
|
# detect external modifications and refuse to clobber them.
|
|
self._board_disk_signature: Optional[Tuple[int, str]] = None
|
|
# Number of timestamped backups to keep in .mcp-backups/ per board file.
|
|
self._auto_save_backup_keep = 20
|
|
self.use_ipc = USE_IPC_BACKEND
|
|
self.ipc_backend = ipc_backend
|
|
self.ipc_board_api = None
|
|
|
|
if self.use_ipc:
|
|
logger.info("Initializing with IPC backend (real-time UI sync enabled)")
|
|
try:
|
|
self.ipc_board_api = self.ipc_backend.get_board()
|
|
logger.info("✓ Got IPC board API")
|
|
except Exception as e:
|
|
logger.warning(f"Could not get IPC board API: {e}")
|
|
else:
|
|
logger.info("Initializing with SWIG backend")
|
|
|
|
logger.info("Initializing command handlers...")
|
|
|
|
# Initialize footprint library manager
|
|
self.footprint_library = FootprintLibraryManager()
|
|
|
|
# Initialize command handlers
|
|
self.project_commands = ProjectCommands(self.board)
|
|
self.board_commands = BoardCommands(self.board)
|
|
self.component_commands = ComponentCommands(self.board, self.footprint_library)
|
|
self.routing_commands = RoutingCommands(self.board)
|
|
self.freerouting_commands = FreeroutingCommands(self.board)
|
|
self.design_rule_commands = DesignRuleCommands(self.board)
|
|
self.export_commands = ExportCommands(self.board)
|
|
self.library_commands = LibraryCommands(self.footprint_library)
|
|
self._current_project_path: Optional[Path] = None # set when boardPath is known
|
|
|
|
# Initialize symbol library manager (for searching local KiCad symbol libraries)
|
|
self.symbol_library_commands = SymbolLibraryCommands()
|
|
|
|
# Initialize JLCPCB API integration
|
|
self.jlcpcb_client = JLCPCBClient() # Official API (requires auth)
|
|
from commands.jlcsearch import JLCSearchClient
|
|
|
|
self.jlcsearch_client = JLCSearchClient() # Public API (no auth required)
|
|
self.jlcpcb_parts = JLCPCBPartsManager()
|
|
|
|
# Schematic-related classes don't need board reference
|
|
# as they operate directly on schematic files
|
|
|
|
# Command routing dictionary
|
|
self.command_routes = {
|
|
# Project commands
|
|
"create_project": self._handle_create_project,
|
|
"open_project": self._handle_open_project,
|
|
"save_project": self.project_commands.save_project,
|
|
"snapshot_project": self._handle_snapshot_project,
|
|
"get_project_info": self.project_commands.get_project_info,
|
|
# Board commands
|
|
"set_board_size": self.board_commands.set_board_size,
|
|
"add_layer": self.board_commands.add_layer,
|
|
"set_active_layer": self.board_commands.set_active_layer,
|
|
"get_board_info": self.board_commands.get_board_info,
|
|
"get_layer_list": self.board_commands.get_layer_list,
|
|
"get_board_2d_view": self.board_commands.get_board_2d_view,
|
|
"get_board_extents": self.board_commands.get_board_extents,
|
|
"add_board_outline": self.board_commands.add_board_outline,
|
|
"add_mounting_hole": self.board_commands.add_mounting_hole,
|
|
"add_text": self.board_commands.add_text,
|
|
"add_board_text": self.board_commands.add_text, # Alias for TypeScript tool
|
|
# Component commands
|
|
"route_pad_to_pad": self.routing_commands.route_pad_to_pad,
|
|
"place_component": self._handle_place_component,
|
|
"move_component": self.component_commands.move_component,
|
|
"rotate_component": self.component_commands.rotate_component,
|
|
"delete_component": self.component_commands.delete_component,
|
|
"edit_component": self.component_commands.edit_component,
|
|
"get_component_properties": self.component_commands.get_component_properties,
|
|
"get_component_list": self.component_commands.get_component_list,
|
|
"find_component": self.component_commands.find_component,
|
|
"get_component_pads": self.component_commands.get_component_pads,
|
|
"get_pad_position": self.component_commands.get_pad_position,
|
|
"place_component_array": self.component_commands.place_component_array,
|
|
"align_components": self.component_commands.align_components,
|
|
"check_courtyard_overlaps": self.component_commands.check_courtyard_overlaps,
|
|
"duplicate_component": self.component_commands.duplicate_component,
|
|
# Routing commands
|
|
"add_net": self.routing_commands.add_net,
|
|
"route_trace": self.routing_commands.route_trace,
|
|
"route_arc_trace": self.routing_commands.route_arc_trace,
|
|
"add_via": self.routing_commands.add_via,
|
|
"delete_trace": self.routing_commands.delete_trace,
|
|
"query_traces": self.routing_commands.query_traces,
|
|
"query_zones": self.routing_commands.query_zones,
|
|
"add_gnd_stitching_vias": self.routing_commands.add_gnd_stitching_vias,
|
|
"modify_trace": self.routing_commands.modify_trace,
|
|
"copy_routing_pattern": self.routing_commands.copy_routing_pattern,
|
|
"get_nets_list": self.routing_commands.get_nets_list,
|
|
"create_netclass": self.routing_commands.create_netclass,
|
|
"add_copper_pour": self.routing_commands.add_copper_pour,
|
|
"route_differential_pair": self.routing_commands.route_differential_pair,
|
|
"refill_zones": self._handle_refill_zones,
|
|
# Design rule commands
|
|
"set_design_rules": self.design_rule_commands.set_design_rules,
|
|
"get_design_rules": self.design_rule_commands.get_design_rules,
|
|
"run_drc": self.design_rule_commands.run_drc,
|
|
"get_drc_violations": self.design_rule_commands.get_drc_violations,
|
|
# Export commands
|
|
"export_gerber": self.export_commands.export_gerber,
|
|
"export_pdf": self.export_commands.export_pdf,
|
|
"export_svg": self.export_commands.export_svg,
|
|
"export_3d": self.export_commands.export_3d,
|
|
"export_bom": self.export_commands.export_bom,
|
|
# Library commands (footprint management)
|
|
"list_libraries": self.library_commands.list_libraries,
|
|
"search_footprints": self.library_commands.search_footprints,
|
|
"list_library_footprints": self.library_commands.list_library_footprints,
|
|
"get_footprint_info": self.library_commands.get_footprint_info,
|
|
# Symbol library commands (local KiCad symbol library search)
|
|
"list_symbol_libraries": self.symbol_library_commands.list_symbol_libraries,
|
|
"search_symbols": self.symbol_library_commands.search_symbols,
|
|
"list_library_symbols": self.symbol_library_commands.list_library_symbols,
|
|
"get_symbol_info": self.symbol_library_commands.get_symbol_info,
|
|
# JLCPCB API commands (complete parts catalog via API)
|
|
"download_jlcpcb_database": self._handle_download_jlcpcb_database,
|
|
"search_jlcpcb_parts": self._handle_search_jlcpcb_parts,
|
|
"get_jlcpcb_part": self._handle_get_jlcpcb_part,
|
|
"get_jlcpcb_database_stats": self._handle_get_jlcpcb_database_stats,
|
|
"suggest_jlcpcb_alternatives": self._handle_suggest_jlcpcb_alternatives,
|
|
# Datasheet commands
|
|
"enrich_datasheets": self._handle_enrich_datasheets,
|
|
"get_datasheet_url": self._handle_get_datasheet_url,
|
|
# Schematic commands
|
|
"create_schematic": self._handle_create_schematic,
|
|
"load_schematic": self._handle_load_schematic,
|
|
"add_schematic_component": self._handle_add_schematic_component,
|
|
"delete_schematic_component": self._handle_delete_schematic_component,
|
|
"edit_schematic_component": self._handle_edit_schematic_component,
|
|
"set_schematic_component_property": self._handle_set_schematic_component_property,
|
|
"remove_schematic_component_property": self._handle_remove_schematic_component_property,
|
|
"get_schematic_component": self._handle_get_schematic_component,
|
|
"add_schematic_wire": self._handle_add_schematic_wire,
|
|
"add_schematic_net_label": self._handle_add_schematic_net_label,
|
|
"add_no_connect": self._handle_add_no_connect,
|
|
"connect_to_net": self._handle_connect_to_net,
|
|
"connect_passthrough": self._handle_connect_passthrough,
|
|
"get_schematic_pin_locations": self._handle_get_schematic_pin_locations,
|
|
"get_net_connections": self._handle_get_net_connections,
|
|
"get_wire_connections": self._handle_get_wire_connections,
|
|
"get_net_at_point": self._handle_get_net_at_point,
|
|
"run_erc": self._handle_run_erc,
|
|
"export_netlist": self._handle_export_netlist,
|
|
"generate_netlist": self._handle_generate_netlist,
|
|
"sync_schematic_to_board": self._handle_sync_schematic_to_board,
|
|
"list_schematic_libraries": self._handle_list_schematic_libraries,
|
|
"get_schematic_view": self._handle_get_schematic_view,
|
|
"list_schematic_components": self._handle_list_schematic_components,
|
|
"list_schematic_nets": self._handle_list_schematic_nets,
|
|
"list_schematic_wires": self._handle_list_schematic_wires,
|
|
"list_schematic_labels": self._handle_list_schematic_labels,
|
|
"move_schematic_component": self._handle_move_schematic_component,
|
|
"rotate_schematic_component": self._handle_rotate_schematic_component,
|
|
"annotate_schematic": self._handle_annotate_schematic,
|
|
"delete_schematic_wire": self._handle_delete_schematic_wire,
|
|
"delete_schematic_net_label": self._handle_delete_schematic_net_label,
|
|
"move_schematic_net_label": self._handle_move_schematic_net_label,
|
|
"export_schematic_pdf": self._handle_export_schematic_pdf,
|
|
"export_schematic_svg": self._handle_export_schematic_svg,
|
|
# Schematic analysis tools (read-only)
|
|
"get_schematic_view_region": self._handle_get_schematic_view_region,
|
|
"find_overlapping_elements": self._handle_find_overlapping_elements,
|
|
"get_elements_in_region": self._handle_get_elements_in_region,
|
|
"find_wires_crossing_symbols": self._handle_find_wires_crossing_symbols,
|
|
"find_orphaned_wires": self._handle_find_orphaned_wires,
|
|
"list_floating_labels": self._handle_list_floating_labels,
|
|
"snap_to_grid": self._handle_snap_to_grid,
|
|
"add_schematic_hierarchical_label": self._handle_add_schematic_hierarchical_label,
|
|
"add_schematic_text": self._handle_add_schematic_text,
|
|
"list_schematic_texts": self._handle_list_schematic_texts,
|
|
"add_sheet_pin": self._handle_add_sheet_pin,
|
|
"import_svg_logo": self._handle_import_svg_logo,
|
|
# UI/Process management commands
|
|
"check_kicad_ui": self._handle_check_kicad_ui,
|
|
"launch_kicad_ui": self._handle_launch_kicad_ui,
|
|
# Internal warm-up (pays wxApp init cost during startup)
|
|
"_warmup": self._handle_warmup,
|
|
# IPC-specific commands (real-time operations)
|
|
"get_backend_info": self._handle_get_backend_info,
|
|
"ipc_add_track": self._handle_ipc_add_track,
|
|
"ipc_add_via": self._handle_ipc_add_via,
|
|
"ipc_add_text": self._handle_ipc_add_text,
|
|
"ipc_list_components": self._handle_ipc_list_components,
|
|
"ipc_get_tracks": self._handle_ipc_get_tracks,
|
|
"ipc_get_vias": self._handle_ipc_get_vias,
|
|
"ipc_save_board": self._handle_ipc_save_board,
|
|
# Footprint commands
|
|
"create_footprint": self._handle_create_footprint,
|
|
"edit_footprint_pad": self._handle_edit_footprint_pad,
|
|
"list_footprint_libraries": self._handle_list_footprint_libraries,
|
|
"register_footprint_library": self._handle_register_footprint_library,
|
|
# Symbol creator commands
|
|
"create_symbol": self._handle_create_symbol,
|
|
"delete_symbol": self._handle_delete_symbol,
|
|
"list_symbols_in_library": self._handle_list_symbols_in_library,
|
|
"register_symbol_library": self._handle_register_symbol_library,
|
|
# Freerouting autoroute commands
|
|
"autoroute": self.freerouting_commands.autoroute,
|
|
"export_dsn": self.freerouting_commands.export_dsn,
|
|
"import_ses": self.freerouting_commands.import_ses,
|
|
"check_freerouting": self.freerouting_commands.check_freerouting,
|
|
}
|
|
|
|
logger.info(f"KiCAD interface initialized (backend: {'IPC' if self.use_ipc else 'SWIG'})")
|
|
|
|
# Commands that can be handled via IPC for real-time updates
|
|
IPC_CAPABLE_COMMANDS = {
|
|
# Routing commands
|
|
"route_trace": "_ipc_route_trace",
|
|
"route_arc_trace": "_ipc_route_arc_trace",
|
|
"add_via": "_ipc_add_via",
|
|
"add_net": "_ipc_add_net",
|
|
"delete_trace": "_ipc_delete_trace",
|
|
"get_nets_list": "_ipc_get_nets_list",
|
|
# Zone commands
|
|
"add_copper_pour": "_ipc_add_copper_pour",
|
|
"refill_zones": "_ipc_refill_zones",
|
|
# Board commands
|
|
"add_text": "_ipc_add_text",
|
|
"add_board_text": "_ipc_add_text",
|
|
"set_board_size": "_ipc_set_board_size",
|
|
"get_board_info": "_ipc_get_board_info",
|
|
"add_board_outline": "_ipc_add_board_outline",
|
|
"add_mounting_hole": "_ipc_add_mounting_hole",
|
|
"get_layer_list": "_ipc_get_layer_list",
|
|
# Component commands
|
|
"place_component": "_ipc_place_component",
|
|
"move_component": "_ipc_move_component",
|
|
"rotate_component": "_ipc_rotate_component",
|
|
"delete_component": "_ipc_delete_component",
|
|
"get_component_list": "_ipc_get_component_list",
|
|
"get_component_properties": "_ipc_get_component_properties",
|
|
# Save command
|
|
"save_project": "_ipc_save_project",
|
|
}
|
|
|
|
def handle_command(self, command: str, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Route command to appropriate handler, preferring IPC when available"""
|
|
logger.info(f"Handling command: {command}")
|
|
logger.debug(f"Command parameters: {params}")
|
|
|
|
try:
|
|
# Check if we can use IPC for this command (real-time UI sync)
|
|
if self.use_ipc and self.ipc_board_api and command in self.IPC_CAPABLE_COMMANDS:
|
|
ipc_handler_name = self.IPC_CAPABLE_COMMANDS[command]
|
|
ipc_handler = getattr(self, ipc_handler_name, None)
|
|
|
|
if ipc_handler:
|
|
logger.info(f"Using IPC backend for {command} (real-time sync)")
|
|
result = ipc_handler(params)
|
|
|
|
# Add indicator that IPC was used
|
|
if isinstance(result, dict):
|
|
result["_backend"] = "ipc"
|
|
result["_realtime"] = True
|
|
|
|
logger.debug(f"IPC command result: {result}")
|
|
return result
|
|
|
|
# Fall back to SWIG-based handler
|
|
if self.use_ipc and command in self.IPC_CAPABLE_COMMANDS:
|
|
logger.warning(
|
|
f"IPC handler not available for {command}, falling back to SWIG (deprecated)"
|
|
)
|
|
|
|
# Get the handler for the command
|
|
handler = self.command_routes.get(command)
|
|
|
|
if handler:
|
|
# Execute the command
|
|
result = handler(params)
|
|
logger.debug(f"Command result: {result}")
|
|
|
|
# Add backend indicator
|
|
if isinstance(result, dict):
|
|
result["_backend"] = "swig"
|
|
result["_realtime"] = False
|
|
|
|
# Update board reference if command was successful
|
|
if result.get("success", False):
|
|
if command == "create_project" or command == "open_project":
|
|
logger.info("Updating board reference...")
|
|
# Get board from the project commands handler
|
|
self.board = self.project_commands.board
|
|
self._update_command_handlers()
|
|
# Record the file's signature so subsequent auto-saves
|
|
# can detect external modifications and refuse to
|
|
# overwrite them.
|
|
self._record_board_signature()
|
|
elif command in self._BOARD_MUTATING_COMMANDS:
|
|
# Auto-save after every board mutation via SWIG.
|
|
# Prevents data loss if Claude hits context limit before
|
|
# an explicit save_project call. When auto-save refuses
|
|
# because the on-disk file changed externally, surface
|
|
# a warning to the caller so they don't believe their
|
|
# mutation was persisted.
|
|
save_status = self._auto_save_board()
|
|
if isinstance(result, dict) and not save_status.get("saved"):
|
|
if save_status.get("warning"):
|
|
result.setdefault("warnings", []).append(save_status["warning"])
|
|
result["autoSave"] = save_status
|
|
|
|
return result
|
|
else:
|
|
logger.error(f"Unknown command: {command}")
|
|
return {
|
|
"success": False,
|
|
"message": f"Unknown command: {command}",
|
|
"errorDetails": "The specified command is not supported",
|
|
}
|
|
|
|
except Exception as e:
|
|
# Get the full traceback
|
|
traceback_str = traceback.format_exc()
|
|
logger.error(f"Error handling command {command}: {str(e)}\n{traceback_str}")
|
|
return {
|
|
"success": False,
|
|
"message": f"Error handling command: {command}",
|
|
"errorDetails": f"{str(e)}\n{traceback_str}",
|
|
}
|
|
|
|
# Board-mutating commands that trigger auto-save on SWIG path
|
|
_BOARD_MUTATING_COMMANDS = {
|
|
"place_component",
|
|
"move_component",
|
|
"rotate_component",
|
|
"delete_component",
|
|
"route_trace",
|
|
"route_arc_trace",
|
|
"route_pad_to_pad",
|
|
"add_via",
|
|
"delete_trace",
|
|
"add_net",
|
|
"add_board_outline",
|
|
"add_mounting_hole",
|
|
"add_text",
|
|
"add_board_text",
|
|
"add_copper_pour",
|
|
"refill_zones",
|
|
"import_svg_logo",
|
|
"sync_schematic_to_board",
|
|
"connect_passthrough",
|
|
"connect_to_net",
|
|
}
|
|
|
|
@staticmethod
|
|
def _disk_signature(path: str) -> Optional[Tuple[int, str]]:
|
|
"""Return (mtime_ns, sha256_hex) for the file, or None if missing/unreadable.
|
|
|
|
The sha256 is always recomputed from disk: the conflict guard in
|
|
``_auto_save_board`` compares hashes (content), not mtime, so we
|
|
cannot use mtime as a cache key without re-introducing the bug
|
|
where two writes inside one mtime tick on a coarse-resolution
|
|
filesystem (FAT32, network mounts, etc.) would mask a real
|
|
content change.
|
|
"""
|
|
try:
|
|
st = os.stat(path)
|
|
h = hashlib.sha256()
|
|
with open(path, "rb") as f:
|
|
for chunk in iter(lambda: f.read(65536), b""):
|
|
h.update(chunk)
|
|
return (st.st_mtime_ns, h.hexdigest())
|
|
except OSError:
|
|
return None
|
|
|
|
def _record_board_signature(self) -> None:
|
|
"""Record the current on-disk signature of self.board's file.
|
|
|
|
Call this after a fresh load (open_project / create_project) or after
|
|
any save we perform ourselves, so that _auto_save_board() can detect
|
|
when an external actor has modified the file in between.
|
|
"""
|
|
if not self.board:
|
|
self._board_disk_signature = None
|
|
return
|
|
try:
|
|
path = self.board.GetFileName()
|
|
except Exception:
|
|
path = None
|
|
self._board_disk_signature = self._disk_signature(path) if path else None
|
|
|
|
def _prune_auto_save_backups(self, backup_dir: str, base_name: str) -> None:
|
|
"""Keep only the most recent `_auto_save_backup_keep` backups for `base_name`."""
|
|
try:
|
|
entries = [
|
|
os.path.join(backup_dir, f)
|
|
for f in os.listdir(backup_dir)
|
|
if f.startswith(base_name + ".")
|
|
]
|
|
entries.sort(key=os.path.getmtime, reverse=True)
|
|
for old in entries[self._auto_save_backup_keep :]:
|
|
try:
|
|
os.remove(old)
|
|
except OSError:
|
|
pass
|
|
except OSError as e:
|
|
logger.debug(f"Backup pruning skipped: {e}")
|
|
|
|
def _auto_save_board(self) -> Dict[str, Any]:
|
|
"""Save the in-memory board to disk after a SWIG-path mutation.
|
|
|
|
Behaviour:
|
|
* If the file's on-disk signature has diverged from the one we
|
|
recorded at load (or at our last successful save), refuse to
|
|
overwrite — an external actor (KiCad GUI, another process, git)
|
|
has touched the file and saving would clobber their changes.
|
|
* Otherwise, copy the existing file to ``<dir>/.mcp-backups/<name>.<ts>``
|
|
(rotating, keeps the most recent `_auto_save_backup_keep`),
|
|
then call pcbnew.SaveBoard().
|
|
* Update the recorded signature on success.
|
|
|
|
Returns a status dict that handle_command merges into the caller's
|
|
response so warnings about refused saves are visible:
|
|
{"saved": True, "boardPath": ..., "backup": <path-or-None>}
|
|
{"saved": False, "skipped": <reason>} -- nothing to save
|
|
{"saved": False, "warning": ..., "diskChangedExternally": True, ...}
|
|
{"saved": False, "error": ...} -- pcbnew error
|
|
"""
|
|
if not self.board:
|
|
return {"saved": False, "skipped": "no board loaded"}
|
|
|
|
try:
|
|
board_path = self.board.GetFileName()
|
|
except Exception as e:
|
|
return {"saved": False, "skipped": f"GetFileName failed: {e}"}
|
|
|
|
if not board_path:
|
|
return {"saved": False, "skipped": "no board path"}
|
|
|
|
expected = self._board_disk_signature
|
|
current = self._disk_signature(board_path)
|
|
|
|
# Only refuse if the file's CONTENT (sha256) has actually diverged
|
|
# from what we recorded. mtime alone is not a conflict signal —
|
|
# `touch`, atime-driven backups, or even some MCP read paths can
|
|
# advance mtime without changing content, and refusing on that
|
|
# basis traps users in a state where every write needs an explicit
|
|
# save_project workaround.
|
|
#
|
|
# If expected is None, treat this as "first save" and proceed —
|
|
# otherwise pre-existing setups (open_project ran before this guard
|
|
# was introduced) would never be able to save.
|
|
if expected is not None and current is not None and expected[1] != current[1]:
|
|
warning = (
|
|
"Auto-save refused: the on-disk PCB file's contents changed "
|
|
"externally since this MCP session loaded it. To avoid "
|
|
"clobbering those changes, the in-memory mutation has NOT "
|
|
"been written to disk. Reload via open_project to refresh, "
|
|
"then re-apply the change."
|
|
)
|
|
logger.warning(f"{warning} ({board_path})")
|
|
logger.warning(f" expected sha256={expected[1][:12]}… mtime_ns={expected[0]}")
|
|
logger.warning(f" current sha256={current[1][:12]}… mtime_ns={current[0]}")
|
|
return {
|
|
"saved": False,
|
|
"warning": warning,
|
|
"boardPath": board_path,
|
|
"diskChangedExternally": True,
|
|
"expectedMtimeNs": expected[0],
|
|
"currentMtimeNs": current[0],
|
|
"memChangesUnsaved": True,
|
|
}
|
|
|
|
# Content matches but mtime advanced (e.g. external `touch`): refresh
|
|
# the recorded mtime so we don't re-hash on every subsequent call.
|
|
if expected is not None and current is not None and expected != current:
|
|
self._board_disk_signature = current
|
|
|
|
# Make a rotating backup of the existing file (best-effort).
|
|
backup_path: Optional[str] = None
|
|
if current is not None:
|
|
try:
|
|
backup_dir = os.path.join(os.path.dirname(board_path) or ".", ".mcp-backups")
|
|
os.makedirs(backup_dir, exist_ok=True)
|
|
stamp = datetime.now().strftime("%Y%m%d-%H%M%S-%f")[:-3]
|
|
base = os.path.basename(board_path)
|
|
backup_path = os.path.join(backup_dir, f"{base}.{stamp}")
|
|
shutil.copy2(board_path, backup_path)
|
|
self._prune_auto_save_backups(backup_dir, base)
|
|
except OSError as e:
|
|
logger.warning(f"Auto-save backup failed (continuing): {e}")
|
|
backup_path = None
|
|
|
|
# Write the board.
|
|
try:
|
|
pcbnew.SaveBoard(board_path, self.board)
|
|
logger.debug(f"Auto-saved board to: {board_path}")
|
|
self._board_disk_signature = self._disk_signature(board_path)
|
|
return {"saved": True, "boardPath": board_path, "backup": backup_path}
|
|
except Exception as e:
|
|
logger.warning(f"Auto-save failed: {e}")
|
|
return {"saved": False, "error": str(e), "backup": backup_path}
|
|
|
|
def _update_command_handlers(self) -> None:
|
|
"""Update board reference in all command handlers"""
|
|
logger.debug("Updating board reference in command handlers")
|
|
self.project_commands.board = self.board
|
|
self.board_commands.board = self.board
|
|
self.component_commands.board = self.board
|
|
self.routing_commands.board = self.board
|
|
self.design_rule_commands.board = self.board
|
|
self.export_commands.board = self.board
|
|
self.freerouting_commands.board = self.board
|
|
|
|
# Schematic command handlers
|
|
def _handle_create_schematic(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Create a new schematic"""
|
|
logger.info("Creating schematic")
|
|
try:
|
|
# Support multiple parameter naming conventions for compatibility:
|
|
# - TypeScript tools use: name, path
|
|
# - Python schema uses: filename, title
|
|
# - Legacy uses: projectName, path, metadata
|
|
project_name = params.get("projectName") or params.get("name") or params.get("title")
|
|
|
|
# Handle filename parameter - it may contain full path
|
|
filename = params.get("filename")
|
|
if filename:
|
|
# If filename provided, extract name and path from it
|
|
if filename.endswith(".kicad_sch"):
|
|
filename = filename[:-10] # Remove .kicad_sch extension
|
|
path = os.path.dirname(filename) or "."
|
|
project_name = project_name or os.path.basename(filename)
|
|
else:
|
|
path = params.get("path", ".")
|
|
metadata = params.get("metadata", {})
|
|
|
|
if not project_name:
|
|
return {
|
|
"success": False,
|
|
"message": "Schematic name is required. Provide 'name', 'projectName', or 'filename' parameter.",
|
|
}
|
|
|
|
sch_path = path if path and path != "." else None
|
|
schematic = SchematicManager.create_schematic(
|
|
project_name, path=sch_path, metadata=metadata
|
|
)
|
|
base_name = (
|
|
project_name if project_name.endswith(".kicad_sch") else f"{project_name}.kicad_sch"
|
|
)
|
|
normalized_path = path or "."
|
|
file_path = os.path.join(normalized_path, base_name)
|
|
success = SchematicManager.save_schematic(schematic, file_path)
|
|
|
|
return {"success": success, "file_path": file_path}
|
|
except Exception as e:
|
|
logger.error(f"Error creating schematic: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_load_schematic(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Load an existing schematic"""
|
|
logger.info("Loading schematic")
|
|
try:
|
|
filename = params.get("filename")
|
|
|
|
if not filename:
|
|
return {"success": False, "message": "Filename is required"}
|
|
|
|
schematic = SchematicManager.load_schematic(filename)
|
|
success = schematic is not None
|
|
|
|
if success:
|
|
metadata = SchematicManager.get_schematic_metadata(schematic)
|
|
return {"success": success, "metadata": metadata}
|
|
else:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
except Exception as e:
|
|
logger.error(f"Error loading schematic: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _project_path_from_filename(self, filename: Optional[str]) -> Optional[Path]:
|
|
"""Resolve a project directory from a filename param.
|
|
|
|
Accepts a .kicad_pro file, a .kicad_pcb file, or a directory.
|
|
"""
|
|
if not filename:
|
|
return None
|
|
try:
|
|
p = Path(filename).expanduser()
|
|
except Exception:
|
|
return None
|
|
if p.is_file() or p.suffix in (".kicad_pro", ".kicad_pcb", ".kicad_sch"):
|
|
return p.parent
|
|
return p
|
|
|
|
def _refresh_symbol_library_for_project(self, project_path: Optional[Path]) -> None:
|
|
"""Rebuild SymbolLibraryCommands' manager so project-scope sym-lib-table
|
|
is visible to subsequent search/list/info calls. No-op if unchanged."""
|
|
if project_path is None:
|
|
return
|
|
self._current_project_path = project_path
|
|
try:
|
|
self.symbol_library_commands.use_project(project_path)
|
|
except Exception as e:
|
|
logger.warning(f"Failed to refresh symbol library for project {project_path}: {e}")
|
|
|
|
def _handle_open_project(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Wrap project_commands.open_project so project-scope symbol libraries
|
|
become visible to subsequent search_symbols / list_symbol_libraries /
|
|
get_symbol_info calls."""
|
|
result = self.project_commands.open_project(params)
|
|
if result.get("success"):
|
|
project_info = result.get("project") or {}
|
|
project_path = self._project_path_from_filename(
|
|
project_info.get("path") or project_info.get("boardPath") or params.get("filename")
|
|
)
|
|
self._refresh_symbol_library_for_project(project_path)
|
|
return result
|
|
|
|
def _handle_create_project(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Wrap project_commands.create_project for the same reason as open_project."""
|
|
result = self.project_commands.create_project(params)
|
|
if result.get("success"):
|
|
project_info = result.get("project") or {}
|
|
project_path = self._project_path_from_filename(
|
|
project_info.get("path")
|
|
or project_info.get("boardPath")
|
|
or params.get("path")
|
|
or params.get("filename")
|
|
)
|
|
self._refresh_symbol_library_for_project(project_path)
|
|
return result
|
|
|
|
def _handle_place_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Place a component on the PCB, with project-local fp-lib-table support.
|
|
If boardPath is given and differs from the currently loaded board, the
|
|
board is reloaded from boardPath before placing — prevents silent failures
|
|
when Claude provides a boardPath that was not yet loaded.
|
|
"""
|
|
from pathlib import Path
|
|
|
|
board_path = params.get("boardPath")
|
|
if board_path:
|
|
board_path_norm = str(Path(board_path).resolve())
|
|
current_board_file = str(Path(self.board.GetFileName()).resolve()) if self.board else ""
|
|
if board_path_norm != current_board_file:
|
|
logger.info(f"boardPath differs from current board — reloading: {board_path}")
|
|
try:
|
|
self.board = pcbnew.LoadBoard(board_path)
|
|
self._update_command_handlers()
|
|
logger.info("Board reloaded from boardPath")
|
|
except Exception as e:
|
|
logger.error(f"Failed to reload board from boardPath: {e}")
|
|
return {
|
|
"success": False,
|
|
"message": f"Could not load board from boardPath: {board_path}",
|
|
"errorDetails": str(e),
|
|
}
|
|
|
|
project_path = Path(board_path).parent
|
|
if project_path != getattr(self, "_current_project_path", None):
|
|
self._current_project_path = project_path
|
|
local_lib = FootprintLibraryManager(project_path=project_path)
|
|
self.component_commands = ComponentCommands(self.board, local_lib)
|
|
logger.info(f"Reloaded FootprintLibraryManager with project_path={project_path}")
|
|
|
|
return self.component_commands.place_component(params)
|
|
|
|
def _handle_add_schematic_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a component to a schematic using text-based injection (no sexpdata)"""
|
|
logger.info("Adding component to schematic")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.dynamic_symbol_loader import DynamicSymbolLoader
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
component = params.get("component", {})
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "Schematic path is required"}
|
|
if not component:
|
|
return {"success": False, "message": "Component definition is required"}
|
|
|
|
comp_type = component.get("type", "R")
|
|
library = component.get("library", "Device")
|
|
reference = component.get("reference", "X?")
|
|
value = component.get("value", comp_type)
|
|
footprint = component.get("footprint", "")
|
|
x = component.get("x", 0)
|
|
y = component.get("y", 0)
|
|
unit = component.get("unit", 1)
|
|
|
|
# Derive project path from schematic path for project-local library resolution.
|
|
# Walk up from the schematic file to find the directory that owns the project
|
|
# (contains sym-lib-table or a .kicad_pro file). Schematics stored in a
|
|
# sub-folder (e.g. sheets/) would otherwise resolve to the wrong directory and
|
|
# miss any project-local sym-lib-table entries.
|
|
schematic_file = Path(schematic_path)
|
|
derived_project_path = schematic_file.parent
|
|
for ancestor in schematic_file.parents:
|
|
if (ancestor / "sym-lib-table").exists() or list(ancestor.glob("*.kicad_pro")):
|
|
derived_project_path = ancestor
|
|
break
|
|
|
|
loader = DynamicSymbolLoader(project_path=derived_project_path)
|
|
loader.add_component(
|
|
schematic_file,
|
|
library,
|
|
comp_type,
|
|
reference=reference,
|
|
value=value,
|
|
footprint=footprint,
|
|
x=x,
|
|
y=y,
|
|
unit=unit,
|
|
project_path=derived_project_path,
|
|
)
|
|
|
|
return {
|
|
"success": True,
|
|
"component_reference": reference,
|
|
"symbol_source": f"{library}:{comp_type}",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error adding component to schematic: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_delete_schematic_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Remove a placed symbol from a schematic using text-based manipulation (no skip writes)"""
|
|
logger.info("Deleting schematic component")
|
|
try:
|
|
import re
|
|
from pathlib import Path
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
reference = params.get("reference")
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
if not reference:
|
|
return {"success": False, "message": "reference is required"}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
with open(sch_file, "r", encoding="utf-8") as f:
|
|
content = f.read()
|
|
|
|
def find_matching_paren(s: str, start: int) -> int:
|
|
"""Find the closing paren matching the opening paren at start."""
|
|
depth = 0
|
|
i = start
|
|
while i < len(s):
|
|
if s[i] == "(":
|
|
depth += 1
|
|
elif s[i] == ")":
|
|
depth -= 1
|
|
if depth == 0:
|
|
return i
|
|
i += 1
|
|
return -1
|
|
|
|
# Skip lib_symbols section
|
|
lib_sym_pos = content.find("(lib_symbols")
|
|
lib_sym_end = find_matching_paren(content, lib_sym_pos) if lib_sym_pos >= 0 else -1
|
|
|
|
# Find ALL placed symbol blocks matching the reference (handles duplicates).
|
|
# Use content-string search so multi-line KiCAD format is handled correctly:
|
|
# KiCAD writes (symbol\n\t\t(lib_id "...") across two lines, which a
|
|
# line-by-line regex would never match.
|
|
blocks_to_delete = [] # list of (char_start, char_end) into content
|
|
search_start = 0
|
|
# Match the opening of any placed-symbol block. KiCAD may emit the
|
|
# children of (symbol ...) in any order — most commonly
|
|
# `(symbol (lib_id "..."))`, but symbols whose library entry has been
|
|
# rescued / customised carry an additional `(lib_name "...")` first:
|
|
# `(symbol (lib_name "...") (lib_id "...") ...)`. Matching just
|
|
# `(symbol\s+(` covers both, and the lib_symbols range check below
|
|
# still excludes library-definition symbols (which use the
|
|
# `(symbol "name" ...)` form with a quoted string, not a paren).
|
|
pattern = re.compile(r"\(symbol\s+\(")
|
|
while True:
|
|
m = pattern.search(content, search_start)
|
|
if not m:
|
|
break
|
|
pos = m.start()
|
|
# Skip blocks inside lib_symbols
|
|
if lib_sym_pos >= 0 and lib_sym_pos <= pos <= lib_sym_end:
|
|
search_start = lib_sym_end + 1
|
|
continue
|
|
end = find_matching_paren(content, pos)
|
|
if end < 0:
|
|
search_start = pos + 1
|
|
continue
|
|
block_text = content[pos : end + 1]
|
|
if re.search(
|
|
r'\(property\s+"Reference"\s+"' + re.escape(reference) + r'"',
|
|
block_text,
|
|
):
|
|
blocks_to_delete.append((pos, end))
|
|
search_start = end + 1
|
|
|
|
if not blocks_to_delete:
|
|
return {
|
|
"success": False,
|
|
"message": f"Component '{reference}' not found in schematic (note: this tool removes schematic symbols, use delete_component for PCB footprints)",
|
|
}
|
|
|
|
# Delete from back to front to preserve character offsets
|
|
for b_start, b_end in sorted(blocks_to_delete, reverse=True):
|
|
# Include any leading newline/whitespace before the block
|
|
trim_start = b_start
|
|
while trim_start > 0 and content[trim_start - 1] in (" ", "\t"):
|
|
trim_start -= 1
|
|
if trim_start > 0 and content[trim_start - 1] == "\n":
|
|
trim_start -= 1
|
|
content = content[:trim_start] + content[b_end + 1 :]
|
|
|
|
with open(sch_file, "w", encoding="utf-8") as f:
|
|
f.write(content)
|
|
|
|
deleted_count = len(blocks_to_delete)
|
|
logger.info(f"Deleted {deleted_count} instance(s) of {reference} from {sch_file.name}")
|
|
return {
|
|
"success": True,
|
|
"reference": reference,
|
|
"deleted_count": deleted_count,
|
|
"schematic": str(sch_file),
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error deleting schematic component: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
# Built-in property names that have dedicated parameters and cannot be removed
|
|
# via the generic removeProperties path. They are also written by KiCad on every
|
|
# save, so deleting them produces an invalid schematic.
|
|
_PROTECTED_PROPERTY_FIELDS = frozenset({"Reference", "Value", "Footprint", "Datasheet"})
|
|
|
|
@staticmethod
|
|
def _escape_sexpr_string(value: str) -> str:
|
|
"""Escape a string for safe insertion into an S-expression double-quoted token."""
|
|
return value.replace("\\", "\\\\").replace('"', '\\"')
|
|
|
|
@staticmethod
|
|
def _find_matching_paren(s: str, start: int) -> int:
|
|
"""Return the index of the closing paren matching the opening paren at `start`.
|
|
|
|
Returns -1 if no match is found. Does not understand string literals — that's
|
|
fine for KiCAD .kicad_sch files because property values cannot contain a
|
|
bare `(` or `)` character (they would be backslash-escaped).
|
|
"""
|
|
depth = 0
|
|
i = start
|
|
while i < len(s):
|
|
if s[i] == "(":
|
|
depth += 1
|
|
elif s[i] == ")":
|
|
depth -= 1
|
|
if depth == 0:
|
|
return i
|
|
i += 1
|
|
return -1
|
|
|
|
def _set_property_in_block(
|
|
self,
|
|
block: str,
|
|
name: str,
|
|
spec: Dict[str, Any],
|
|
default_position: Tuple[float, float],
|
|
) -> Tuple[str, str]:
|
|
"""Add or update a property within a placed-symbol block.
|
|
|
|
Args:
|
|
block: The full text of the (symbol ...) block.
|
|
name: Property name (e.g. "MPN", "Manufacturer").
|
|
spec: Dict that may contain keys: value, x, y, angle, hide, fontSize.
|
|
default_position: (x, y) of the parent symbol — used as the default
|
|
location for newly-created properties so the field is anchored
|
|
near the component, not at (0, 0).
|
|
|
|
Returns:
|
|
Tuple of (new_block_text, action_taken) where action is "added" or "updated".
|
|
"""
|
|
import re
|
|
|
|
new_value = spec.get("value")
|
|
new_x = spec.get("x")
|
|
new_y = spec.get("y")
|
|
new_angle = spec.get("angle")
|
|
new_hide = spec.get("hide")
|
|
font_size = spec.get("fontSize", 1.27)
|
|
|
|
existing_match = re.search(
|
|
r'\(property\s+"' + re.escape(name) + r'"\s+"',
|
|
block,
|
|
)
|
|
|
|
if existing_match:
|
|
# Property exists — patch value / position / hide in place
|
|
if new_value is not None:
|
|
escaped = self._escape_sexpr_string(str(new_value))
|
|
block = re.sub(
|
|
r'(\(property\s+"' + re.escape(name) + r'"\s+)"[^"]*"',
|
|
rf'\1"{escaped}"',
|
|
block,
|
|
count=1,
|
|
)
|
|
|
|
if new_x is not None or new_y is not None or new_angle is not None:
|
|
pos_match = re.search(
|
|
r'(\(property\s+"'
|
|
+ re.escape(name)
|
|
+ r'"\s+"[^"]*"\s+\(at\s+)([\d\.\-]+)\s+([\d\.\-]+)\s+([\d\.\-]+)(\s*\))',
|
|
block,
|
|
)
|
|
if pos_match:
|
|
cx = new_x if new_x is not None else float(pos_match.group(2))
|
|
cy = new_y if new_y is not None else float(pos_match.group(3))
|
|
ca = new_angle if new_angle is not None else float(pos_match.group(4))
|
|
block = (
|
|
block[: pos_match.start()]
|
|
+ pos_match.group(1)
|
|
+ f"{cx} {cy} {ca}"
|
|
+ pos_match.group(5)
|
|
+ block[pos_match.end() :]
|
|
)
|
|
|
|
if new_hide is not None:
|
|
block = self._set_hide_on_property(block, name, bool(new_hide))
|
|
|
|
return block, "updated"
|
|
|
|
# Property does not exist — append a new one after the last existing property
|
|
if new_value is None:
|
|
# Adding a brand-new property requires at least a value
|
|
raise ValueError(
|
|
f"Property '{name}' does not exist on this component yet — supply a value to create it"
|
|
)
|
|
|
|
cx = new_x if new_x is not None else default_position[0]
|
|
cy = new_y if new_y is not None else default_position[1]
|
|
ca = new_angle if new_angle is not None else 0
|
|
# New properties default to hidden (BOM/sourcing data normally has no
|
|
# visible footprint on the schematic canvas).
|
|
hide_str = "(hide yes)" if (new_hide is None or new_hide) else "(hide no)"
|
|
escaped = self._escape_sexpr_string(str(new_value))
|
|
escaped_name = self._escape_sexpr_string(str(name))
|
|
|
|
new_prop = (
|
|
f' (property "{escaped_name}" "{escaped}" (at {cx} {cy} {ca})\n'
|
|
f" (effects (font (size {font_size} {font_size})) {hide_str})\n"
|
|
f" )"
|
|
)
|
|
|
|
# Find the last existing property block and insert immediately after it.
|
|
last_prop_end = -1
|
|
for m in re.finditer(r'\(property\s+"', block):
|
|
end = self._find_matching_paren(block, m.start())
|
|
if end > last_prop_end:
|
|
last_prop_end = end
|
|
|
|
if last_prop_end < 0:
|
|
# No properties at all — insert just before the closing paren of the symbol
|
|
block_close = block.rfind(")")
|
|
if block_close < 0:
|
|
raise ValueError("Malformed symbol block: no closing paren")
|
|
block = block[:block_close] + "\n" + new_prop + "\n " + block[block_close:]
|
|
else:
|
|
block = block[: last_prop_end + 1] + "\n" + new_prop + block[last_prop_end + 1 :]
|
|
|
|
return block, "added"
|
|
|
|
def _set_hide_on_property(self, block: str, name: str, hide: bool) -> str:
|
|
"""Set the (hide yes|no) flag on a named property's effects clause.
|
|
|
|
Handles three pre-existing forms:
|
|
(effects (font (size 1.27 1.27))) — no hide flag
|
|
(effects (font (size 1.27 1.27)) hide) — legacy bare token
|
|
(effects (font (size 1.27 1.27)) (hide yes|no)) — KiCad 9 form
|
|
"""
|
|
import re
|
|
|
|
prop_match = re.search(
|
|
r'\(property\s+"' + re.escape(name) + r'"',
|
|
block,
|
|
)
|
|
if not prop_match:
|
|
return block
|
|
prop_start = prop_match.start()
|
|
prop_end = self._find_matching_paren(block, prop_start)
|
|
if prop_end < 0:
|
|
return block
|
|
|
|
# Locate the (effects ...) clause inside the property
|
|
prop_segment = block[prop_start : prop_end + 1]
|
|
eff_match = re.search(r"\(effects\b", prop_segment)
|
|
if not eff_match:
|
|
return block
|
|
eff_start = prop_start + eff_match.start()
|
|
eff_end = self._find_matching_paren(block, eff_start)
|
|
if eff_end < 0:
|
|
return block
|
|
|
|
eff_inner = block[eff_start + 1 : eff_end] # 'effects (font ...) ...'
|
|
eff_inner = re.sub(r"\s*\(hide\s+(yes|no)\)", "", eff_inner)
|
|
eff_inner = re.sub(r"\s+hide\b(?!\s+(yes|no))", "", eff_inner)
|
|
eff_inner = eff_inner.rstrip() + f' (hide {"yes" if hide else "no"})'
|
|
|
|
new_effects = "(" + eff_inner + ")"
|
|
return block[:eff_start] + new_effects + block[eff_end + 1 :]
|
|
|
|
def _remove_property_from_block(self, block: str, name: str) -> Tuple[str, bool]:
|
|
"""Remove a property from the symbol block. Returns (new_block, removed_bool)."""
|
|
import re
|
|
|
|
m = re.search(r'\(property\s+"' + re.escape(name) + r'"\s+"', block)
|
|
if not m:
|
|
return block, False
|
|
start = m.start()
|
|
end = self._find_matching_paren(block, start)
|
|
if end < 0:
|
|
return block, False
|
|
|
|
# Trim surrounding whitespace (leading newline + indent) so the resulting
|
|
# file does not develop blank lines after every removal.
|
|
trim_start = start
|
|
while trim_start > 0 and block[trim_start - 1] in (" ", "\t"):
|
|
trim_start -= 1
|
|
if trim_start > 0 and block[trim_start - 1] == "\n":
|
|
trim_start -= 1
|
|
return block[:trim_start] + block[end + 1 :], True
|
|
|
|
def _handle_edit_schematic_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Update properties of a placed symbol in a schematic.
|
|
|
|
Supports updating the standard fields (footprint / value / reference rename),
|
|
repositioning field labels, and managing **arbitrary custom properties**
|
|
(MPN, Manufacturer, Distributor part numbers, Voltage, Dielectric, Tolerance,
|
|
LCSC, etc.) used by BOM/CPL exporters and JLCPCB / Digi-Key sourcing.
|
|
|
|
Uses text-based in-place editing — preserves position, UUID, and all
|
|
unrelated fields.
|
|
"""
|
|
logger.info("Editing schematic component")
|
|
try:
|
|
import re
|
|
from pathlib import Path
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
reference = params.get("reference")
|
|
new_footprint = params.get("footprint")
|
|
new_value = params.get("value")
|
|
new_reference = params.get("newReference")
|
|
# dict: {"Reference": {"x": 1, "y": 2, "angle": 0}}
|
|
field_positions = params.get("fieldPositions")
|
|
# dict: {"MPN": "RC0603FR-0710KL"} OR {"MPN": {"value": "...", "hide": true}}
|
|
properties = params.get("properties")
|
|
# list[str]: ["OldField"] — protected built-ins are rejected
|
|
remove_properties = params.get("removeProperties")
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
if not reference:
|
|
return {"success": False, "message": "reference is required"}
|
|
if not any(
|
|
[
|
|
new_footprint is not None,
|
|
new_value is not None,
|
|
new_reference is not None,
|
|
field_positions is not None,
|
|
properties is not None,
|
|
remove_properties is not None,
|
|
]
|
|
):
|
|
return {
|
|
"success": False,
|
|
"message": (
|
|
"At least one of footprint, value, newReference, fieldPositions, "
|
|
"properties, or removeProperties must be provided"
|
|
),
|
|
}
|
|
|
|
# Reject removal attempts targeting protected built-in fields up-front
|
|
if remove_properties:
|
|
blocked = [n for n in remove_properties if n in self._PROTECTED_PROPERTY_FIELDS]
|
|
if blocked:
|
|
return {
|
|
"success": False,
|
|
"message": (
|
|
f"Cannot remove built-in field(s) {blocked}: use the dedicated "
|
|
"value/footprint/newReference parameters or set the value to ''"
|
|
),
|
|
}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
with open(sch_file, "r", encoding="utf-8") as f:
|
|
content = f.read()
|
|
|
|
# Skip lib_symbols section
|
|
lib_sym_pos = content.find("(lib_symbols")
|
|
lib_sym_end = (
|
|
self._find_matching_paren(content, lib_sym_pos) if lib_sym_pos >= 0 else -1
|
|
)
|
|
|
|
# Find placed symbol blocks that match the reference. KiCAD may
|
|
# serialise the children of (symbol ...) in different orders —
|
|
# `(symbol (lib_id "..."))` is the common case but rescued or
|
|
# locally-customised symbols carry an extra `(lib_name "...")`
|
|
# before the lib_id: `(symbol (lib_name "...") (lib_id "..."))`.
|
|
# Match any opening paren after `(symbol`; the lib_symbols range
|
|
# check below excludes library-definition symbols, which use the
|
|
# `(symbol "name" ...)` form (quoted string, not paren).
|
|
block_start = block_end = None
|
|
search_start = 0
|
|
pattern = re.compile(r"\(symbol\s+\(")
|
|
while True:
|
|
m = pattern.search(content, search_start)
|
|
if not m:
|
|
break
|
|
pos = m.start()
|
|
# Skip if inside lib_symbols section
|
|
if lib_sym_pos >= 0 and lib_sym_pos <= pos <= lib_sym_end:
|
|
search_start = lib_sym_end + 1
|
|
continue
|
|
end = self._find_matching_paren(content, pos)
|
|
if end < 0:
|
|
search_start = pos + 1
|
|
continue
|
|
block_text = content[pos : end + 1]
|
|
if re.search(
|
|
r'\(property\s+"Reference"\s+"' + re.escape(reference) + r'"',
|
|
block_text,
|
|
):
|
|
block_start, block_end = pos, end
|
|
break
|
|
search_start = end + 1
|
|
|
|
if block_start is None or block_end is None:
|
|
return {
|
|
"success": False,
|
|
"message": f"Component '{reference}' not found in schematic",
|
|
}
|
|
|
|
# Apply property replacements within the found block
|
|
block_text = content[block_start : block_end + 1]
|
|
|
|
# Determine the parent symbol position so that newly-added properties
|
|
# default to a sensible location (anchored near the component).
|
|
# KiCAD always emits the symbol's own (at x y angle) before any
|
|
# (property ...) child blocks, so the FIRST (at ...) inside the
|
|
# symbol block is the symbol origin regardless of whether
|
|
# (lib_name ...) precedes (lib_id ...).
|
|
comp_at = re.search(
|
|
r"\(at\s+([\d\.\-]+)\s+([\d\.\-]+)",
|
|
block_text,
|
|
)
|
|
comp_origin: Tuple[float, float] = (
|
|
(float(comp_at.group(1)), float(comp_at.group(2))) if comp_at else (0.0, 0.0)
|
|
)
|
|
|
|
if new_footprint is not None:
|
|
escaped_fp = self._escape_sexpr_string(str(new_footprint))
|
|
block_text = re.sub(
|
|
r'(\(property\s+"Footprint"\s+)"[^"]*"',
|
|
rf'\1"{escaped_fp}"',
|
|
block_text,
|
|
)
|
|
if new_value is not None:
|
|
escaped_v = self._escape_sexpr_string(str(new_value))
|
|
block_text = re.sub(
|
|
r'(\(property\s+"Value"\s+)"[^"]*"',
|
|
rf'\1"{escaped_v}"',
|
|
block_text,
|
|
)
|
|
if new_reference is not None:
|
|
escaped_r = self._escape_sexpr_string(str(new_reference))
|
|
block_text = re.sub(
|
|
r'(\(property\s+"Reference"\s+)"[^"]*"',
|
|
rf'\1"{escaped_r}"',
|
|
block_text,
|
|
)
|
|
# Also update the (reference "...") leaves inside the symbol's
|
|
# (instances) → (project) → (path) subtree. KiCad reads those
|
|
# entries — not the (property "Reference" ...) field — when
|
|
# generating netlists and syncing the PCB via "Update PCB from
|
|
# Schematic", so leaving them stale produces a silent
|
|
# reference mismatch where eeschema shows the new ref but ERC
|
|
# / netlist export / PCB sync all use the old one. See #126.
|
|
instances_pos = block_text.find("(instances")
|
|
if instances_pos >= 0:
|
|
instances_end = self._find_matching_paren(block_text, instances_pos)
|
|
if instances_end >= 0:
|
|
instances_block = block_text[instances_pos : instances_end + 1]
|
|
updated_instances = re.sub(
|
|
r'(\(reference\s+)"' + re.escape(reference) + r'"',
|
|
rf'\1"{escaped_r}"',
|
|
instances_block,
|
|
)
|
|
block_text = (
|
|
block_text[:instances_pos]
|
|
+ updated_instances
|
|
+ block_text[instances_end + 1 :]
|
|
)
|
|
if field_positions is not None:
|
|
for field_name, pos in field_positions.items():
|
|
x = pos.get("x", 0)
|
|
y = pos.get("y", 0)
|
|
angle = pos.get("angle", 0)
|
|
block_text = re.sub(
|
|
r'(\(property\s+"'
|
|
+ re.escape(field_name)
|
|
+ r'"\s+"[^"]*"\s+)\(at\s+[\d\.\-]+\s+[\d\.\-]+\s+[\d\.\-]+\s*\)',
|
|
rf"\1(at {x} {y} {angle})",
|
|
block_text,
|
|
)
|
|
|
|
properties_added: Dict[str, Any] = {}
|
|
properties_updated: Dict[str, Any] = {}
|
|
if properties:
|
|
if not isinstance(properties, dict):
|
|
return {
|
|
"success": False,
|
|
"message": "properties must be a dict mapping property name -> value or spec",
|
|
}
|
|
for name, spec in properties.items():
|
|
if not isinstance(name, str) or not name:
|
|
return {
|
|
"success": False,
|
|
"message": f"Invalid property name: {name!r}",
|
|
}
|
|
# Normalise scalar values to a spec dict with just {"value": ...}
|
|
if not isinstance(spec, dict):
|
|
spec = {"value": spec}
|
|
try:
|
|
block_text, action = self._set_property_in_block(
|
|
block_text, name, spec, comp_origin
|
|
)
|
|
except ValueError as ve:
|
|
return {"success": False, "message": str(ve)}
|
|
target = properties_added if action == "added" else properties_updated
|
|
target[name] = spec.get("value")
|
|
|
|
properties_removed: list = []
|
|
if remove_properties:
|
|
if not isinstance(remove_properties, list):
|
|
return {
|
|
"success": False,
|
|
"message": "removeProperties must be a list of property names",
|
|
}
|
|
for name in remove_properties:
|
|
block_text, removed = self._remove_property_from_block(block_text, name)
|
|
if removed:
|
|
properties_removed.append(name)
|
|
|
|
content = content[:block_start] + block_text + content[block_end + 1 :]
|
|
|
|
with open(sch_file, "w", encoding="utf-8") as f:
|
|
f.write(content)
|
|
|
|
changes: Dict[str, Any] = {
|
|
k: v
|
|
for k, v in {
|
|
"footprint": new_footprint,
|
|
"value": new_value,
|
|
"reference": new_reference,
|
|
}.items()
|
|
if v is not None
|
|
}
|
|
if field_positions is not None:
|
|
changes["fieldPositions"] = field_positions
|
|
if properties_added:
|
|
changes["propertiesAdded"] = properties_added
|
|
if properties_updated:
|
|
changes["propertiesUpdated"] = properties_updated
|
|
if properties_removed:
|
|
changes["propertiesRemoved"] = properties_removed
|
|
|
|
logger.info(f"Edited schematic component {reference}: {changes}")
|
|
return {"success": True, "reference": reference, "updated": changes}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error editing schematic component: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_set_schematic_component_property(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add or update a single property on a placed schematic symbol.
|
|
|
|
Convenience wrapper around `edit_schematic_component` for the very common
|
|
case of setting one BOM/sourcing field at a time. The property is created
|
|
if it does not already exist, otherwise its value (and optionally its
|
|
position / visibility) is updated in place.
|
|
"""
|
|
logger.info("Setting schematic component property")
|
|
name = params.get("name")
|
|
if not isinstance(name, str) or not name:
|
|
return {"success": False, "message": "name is required"}
|
|
if "value" not in params:
|
|
return {"success": False, "message": "value is required"}
|
|
|
|
spec: Dict[str, Any] = {"value": params["value"]}
|
|
for key in ("x", "y", "angle", "hide", "fontSize"):
|
|
if params.get(key) is not None:
|
|
spec[key] = params[key]
|
|
|
|
return self._handle_edit_schematic_component(
|
|
{
|
|
"schematicPath": params.get("schematicPath"),
|
|
"reference": params.get("reference"),
|
|
"properties": {name: spec},
|
|
}
|
|
)
|
|
|
|
def _handle_remove_schematic_component_property(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Remove a single custom property from a placed schematic symbol.
|
|
|
|
Built-in fields (Reference, Value, Footprint, Datasheet) cannot be
|
|
removed — use `edit_schematic_component` to clear them instead.
|
|
"""
|
|
logger.info("Removing schematic component property")
|
|
name = params.get("name")
|
|
if not isinstance(name, str) or not name:
|
|
return {"success": False, "message": "name is required"}
|
|
return self._handle_edit_schematic_component(
|
|
{
|
|
"schematicPath": params.get("schematicPath"),
|
|
"reference": params.get("reference"),
|
|
"removeProperties": [name],
|
|
}
|
|
)
|
|
|
|
def _handle_get_schematic_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Return full component info: position and all field values with their (at x y angle) positions."""
|
|
logger.info("Getting schematic component info")
|
|
try:
|
|
import re
|
|
from pathlib import Path
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
reference = params.get("reference")
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
if not reference:
|
|
return {"success": False, "message": "reference is required"}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
with open(sch_file, "r", encoding="utf-8") as f:
|
|
content = f.read()
|
|
|
|
def find_matching_paren(s: str, start: int) -> int:
|
|
depth = 0
|
|
i = start
|
|
while i < len(s):
|
|
if s[i] == "(":
|
|
depth += 1
|
|
elif s[i] == ")":
|
|
depth -= 1
|
|
if depth == 0:
|
|
return i
|
|
i += 1
|
|
return -1
|
|
|
|
# Skip lib_symbols section
|
|
lib_sym_pos = content.find("(lib_symbols")
|
|
lib_sym_end = find_matching_paren(content, lib_sym_pos) if lib_sym_pos >= 0 else -1
|
|
|
|
# Find the placed symbol block for this reference. KiCAD may emit
|
|
# the children of (symbol ...) in different orders — most commonly
|
|
# `(symbol (lib_id "..."))`, but symbols whose library entry has
|
|
# been rescued / customised carry an extra `(lib_name "...")` first
|
|
# (`(symbol (lib_name "...") (lib_id "..."))`). Match `(symbol\s+(`
|
|
# — any opening paren — to handle both. The lib_symbols range check
|
|
# below excludes library-definition symbols, which use the
|
|
# `(symbol "name" ...)` form (quoted string, not paren).
|
|
block_start = block_end = None
|
|
search_start = 0
|
|
pattern = re.compile(r"\(symbol\s+\(")
|
|
while True:
|
|
m = pattern.search(content, search_start)
|
|
if not m:
|
|
break
|
|
pos = m.start()
|
|
if lib_sym_pos >= 0 and lib_sym_pos <= pos <= lib_sym_end:
|
|
search_start = lib_sym_end + 1
|
|
continue
|
|
end = find_matching_paren(content, pos)
|
|
if end < 0:
|
|
search_start = pos + 1
|
|
continue
|
|
block_text = content[pos : end + 1]
|
|
if re.search(
|
|
r'\(property\s+"Reference"\s+"' + re.escape(reference) + r'"',
|
|
block_text,
|
|
):
|
|
block_start, block_end = pos, end
|
|
break
|
|
search_start = end + 1
|
|
|
|
if block_start is None or block_end is None:
|
|
return {
|
|
"success": False,
|
|
"message": f"Component '{reference}' not found in schematic",
|
|
}
|
|
|
|
block_text = content[block_start : block_end + 1]
|
|
|
|
# Extract component position: the first (at x y angle) inside the
|
|
# symbol block. KiCAD always writes the symbol's own (at) before
|
|
# any (property ...) child blocks, so the first match is the
|
|
# symbol origin regardless of the (lib_name)/(lib_id) ordering.
|
|
comp_at = re.search(
|
|
r"\(at\s+([\d\.\-]+)\s+([\d\.\-]+)\s+([\d\.\-]+)\s*\)",
|
|
block_text,
|
|
)
|
|
if comp_at:
|
|
comp_pos = {
|
|
"x": float(comp_at.group(1)),
|
|
"y": float(comp_at.group(2)),
|
|
"angle": float(comp_at.group(3)),
|
|
}
|
|
else:
|
|
comp_pos = None
|
|
|
|
# Extract all properties with their at positions
|
|
prop_pattern = re.compile(
|
|
r'\(property\s+"([^"]*)"\s+"([^"]*)"\s+\(at\s+([\d\.\-]+)\s+([\d\.\-]+)\s+([\d\.\-]+)\s*\)'
|
|
)
|
|
fields = {}
|
|
for m in prop_pattern.finditer(block_text):
|
|
name, value, x, y, angle = (
|
|
m.group(1),
|
|
m.group(2),
|
|
m.group(3),
|
|
m.group(4),
|
|
m.group(5),
|
|
)
|
|
fields[name] = {
|
|
"value": value,
|
|
"x": float(x),
|
|
"y": float(y),
|
|
"angle": float(angle),
|
|
}
|
|
|
|
return {
|
|
"success": True,
|
|
"reference": reference,
|
|
"position": comp_pos,
|
|
"fields": fields,
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error getting schematic component: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_add_schematic_wire(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a wire to a schematic using WireManager, with optional pin snapping"""
|
|
logger.info("Adding wire to schematic")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.wire_manager import WireManager
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
points = params.get("waypoints")
|
|
properties = params.get("properties", {})
|
|
snap_to_pins = params.get("snapToPins", True)
|
|
snap_tolerance = params.get("snapTolerance", 1.0)
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "Schematic path is required"}
|
|
if not points or len(points) < 2:
|
|
return {
|
|
"success": False,
|
|
"message": "At least 2 waypoints are required",
|
|
}
|
|
|
|
# Make a mutable copy of points
|
|
points = [list(p) for p in points]
|
|
|
|
# Pin snapping: adjust first and last endpoints to nearest pin
|
|
snapped_info = []
|
|
if snap_to_pins:
|
|
from commands.pin_locator import PinLocator
|
|
|
|
locator = PinLocator()
|
|
sch_path = Path(schematic_path)
|
|
|
|
# Load schematic to iterate all symbols
|
|
from skip import Schematic as SkipSchematic
|
|
|
|
sch = SkipSchematic(str(sch_path))
|
|
|
|
# Collect all pin locations: list of (ref, pin_num, [x, y])
|
|
all_pins = []
|
|
for symbol in sch.symbol:
|
|
if not hasattr(symbol.property, "Reference"):
|
|
continue
|
|
ref = symbol.property.Reference.value
|
|
if ref.startswith("_TEMPLATE"):
|
|
continue
|
|
pin_locs = locator.get_all_symbol_pins(sch_path, ref)
|
|
for pin_num, coords in pin_locs.items():
|
|
all_pins.append((ref, pin_num, coords))
|
|
|
|
def find_nearest_pin(point: Any, tolerance: Any) -> Any:
|
|
"""Find the nearest pin within tolerance of a point."""
|
|
best = None
|
|
best_dist = tolerance
|
|
for ref, pin_num, coords in all_pins:
|
|
dx = point[0] - coords[0]
|
|
dy = point[1] - coords[1]
|
|
dist = (dx * dx + dy * dy) ** 0.5
|
|
if dist <= best_dist:
|
|
best_dist = dist
|
|
best = (ref, pin_num, coords)
|
|
return best
|
|
|
|
# Snap first endpoint
|
|
match = find_nearest_pin(points[0], snap_tolerance)
|
|
if match:
|
|
ref, pin_num, coords = match
|
|
logger.info(
|
|
f"Snapped start point {points[0]} -> {coords} (pin {ref}/{pin_num})"
|
|
)
|
|
snapped_info.append(
|
|
f"start snapped to {ref}/{pin_num} at [{coords[0]}, {coords[1]}]"
|
|
)
|
|
points[0] = list(coords)
|
|
|
|
# Snap last endpoint
|
|
match = find_nearest_pin(points[-1], snap_tolerance)
|
|
if match:
|
|
ref, pin_num, coords = match
|
|
logger.info(f"Snapped end point {points[-1]} -> {coords} (pin {ref}/{pin_num})")
|
|
snapped_info.append(
|
|
f"end snapped to {ref}/{pin_num} at [{coords[0]}, {coords[1]}]"
|
|
)
|
|
points[-1] = list(coords)
|
|
|
|
# Extract wire properties
|
|
stroke_width = properties.get("stroke_width", 0)
|
|
stroke_type = properties.get("stroke_type", "default")
|
|
|
|
# Use WireManager for S-expression manipulation
|
|
if len(points) == 2:
|
|
success = WireManager.add_wire(
|
|
Path(schematic_path),
|
|
points[0],
|
|
points[1],
|
|
stroke_width=stroke_width,
|
|
stroke_type=stroke_type,
|
|
)
|
|
else:
|
|
success = WireManager.add_polyline_wire(
|
|
Path(schematic_path),
|
|
points,
|
|
stroke_width=stroke_width,
|
|
stroke_type=stroke_type,
|
|
)
|
|
|
|
if success:
|
|
message = "Wire added successfully"
|
|
if snapped_info:
|
|
message += "; " + "; ".join(snapped_info)
|
|
return {"success": True, "message": message}
|
|
else:
|
|
return {"success": False, "message": "Failed to add wire"}
|
|
except Exception as e:
|
|
logger.error(f"Error adding wire to schematic: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {
|
|
"success": False,
|
|
"message": str(e),
|
|
"errorDetails": traceback.format_exc(),
|
|
}
|
|
|
|
def _handle_list_schematic_libraries(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List available symbol libraries"""
|
|
logger.info("Listing schematic libraries")
|
|
try:
|
|
search_paths = params.get("searchPaths")
|
|
|
|
libraries = SchematicLibraryManager.list_available_libraries(search_paths)
|
|
return {"success": True, "libraries": libraries}
|
|
except Exception as e:
|
|
logger.error(f"Error listing schematic libraries: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_find_unconnected_pins(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List component pins with no wire/label/power symbol touching them"""
|
|
logger.info("Finding unconnected pins")
|
|
try:
|
|
from commands.schematic_analysis import find_unconnected_pins
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
result = find_unconnected_pins(schematic_path)
|
|
return {"success": True, **result}
|
|
except ImportError:
|
|
return {
|
|
"success": False,
|
|
"message": "schematic_analysis module not available",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error finding unconnected pins: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_check_wire_collisions(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Detect wires passing through component bodies without connecting to pins"""
|
|
logger.info("Checking wire collisions")
|
|
try:
|
|
from commands.schematic_analysis import check_wire_collisions
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
result = check_wire_collisions(schematic_path)
|
|
return {"success": True, **result}
|
|
except ImportError:
|
|
return {
|
|
"success": False,
|
|
"message": "schematic_analysis module not available",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error checking wire collisions: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
# ------------------------------------------------------------------ #
|
|
# Footprint handlers #
|
|
# ------------------------------------------------------------------ #
|
|
|
|
def _handle_create_footprint(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Create a new .kicad_mod footprint file in a .pretty library."""
|
|
logger.info(f"create_footprint: {params.get('name')} in {params.get('libraryPath')}")
|
|
try:
|
|
creator = FootprintCreator()
|
|
return creator.create_footprint(
|
|
library_path=params.get("libraryPath", ""),
|
|
name=params.get("name", ""),
|
|
description=params.get("description", ""),
|
|
tags=params.get("tags", ""),
|
|
pads=params.get("pads", []),
|
|
courtyard=params.get("courtyard"),
|
|
silkscreen=params.get("silkscreen"),
|
|
fab_layer=params.get("fabLayer"),
|
|
ref_position=params.get("refPosition"),
|
|
value_position=params.get("valuePosition"),
|
|
overwrite=params.get("overwrite", False),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"create_footprint error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
def _handle_edit_footprint_pad(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Edit an existing pad in a .kicad_mod file."""
|
|
logger.info(
|
|
f"edit_footprint_pad: pad {params.get('padNumber')} in {params.get('footprintPath')}"
|
|
)
|
|
try:
|
|
creator = FootprintCreator()
|
|
return creator.edit_footprint_pad(
|
|
footprint_path=params.get("footprintPath", ""),
|
|
pad_number=str(params.get("padNumber", "1")),
|
|
size=params.get("size"),
|
|
at=params.get("at"),
|
|
drill=params.get("drill"),
|
|
shape=params.get("shape"),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"edit_footprint_pad error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
def _handle_list_footprint_libraries(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List .pretty footprint libraries and their contents."""
|
|
logger.info("list_footprint_libraries")
|
|
try:
|
|
creator = FootprintCreator()
|
|
return creator.list_footprint_libraries(search_paths=params.get("searchPaths"))
|
|
except Exception as e:
|
|
logger.error(f"list_footprint_libraries error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
def _handle_register_footprint_library(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Register a .pretty library in KiCAD's fp-lib-table."""
|
|
logger.info(f"register_footprint_library: {params.get('libraryPath')}")
|
|
try:
|
|
creator = FootprintCreator()
|
|
return creator.register_footprint_library(
|
|
library_path=params.get("libraryPath", ""),
|
|
library_name=params.get("libraryName"),
|
|
description=params.get("description", ""),
|
|
scope=params.get("scope", "project"),
|
|
project_path=params.get("projectPath"),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"register_footprint_library error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
# ------------------------------------------------------------------ #
|
|
# Symbol creator handlers #
|
|
# ------------------------------------------------------------------ #
|
|
|
|
def _handle_create_symbol(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Create a new symbol in a .kicad_sym library."""
|
|
logger.info(f"create_symbol: {params.get('name')} in {params.get('libraryPath')}")
|
|
try:
|
|
creator = SymbolCreator()
|
|
return creator.create_symbol(
|
|
library_path=params.get("libraryPath", ""),
|
|
name=params.get("name", ""),
|
|
reference_prefix=params.get("referencePrefix", "U"),
|
|
description=params.get("description", ""),
|
|
keywords=params.get("keywords", ""),
|
|
datasheet=params.get("datasheet", "~"),
|
|
footprint=params.get("footprint", ""),
|
|
in_bom=params.get("inBom", True),
|
|
on_board=params.get("onBoard", True),
|
|
pins=params.get("pins", []),
|
|
rectangles=params.get("rectangles", []),
|
|
polylines=params.get("polylines", []),
|
|
overwrite=params.get("overwrite", False),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"create_symbol error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
def _handle_delete_symbol(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Delete a symbol from a .kicad_sym library."""
|
|
logger.info(f"delete_symbol: {params.get('name')} from {params.get('libraryPath')}")
|
|
try:
|
|
creator = SymbolCreator()
|
|
return creator.delete_symbol(
|
|
library_path=params.get("libraryPath", ""),
|
|
name=params.get("name", ""),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"delete_symbol error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
def _handle_list_symbols_in_library(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List all symbols in a .kicad_sym file."""
|
|
logger.info(f"list_symbols_in_library: {params.get('libraryPath')}")
|
|
try:
|
|
creator = SymbolCreator()
|
|
return creator.list_symbols(
|
|
library_path=params.get("libraryPath", ""),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"list_symbols_in_library error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
def _handle_register_symbol_library(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Register a .kicad_sym library in KiCAD's sym-lib-table."""
|
|
logger.info(f"register_symbol_library: {params.get('libraryPath')}")
|
|
try:
|
|
creator = SymbolCreator()
|
|
return creator.register_symbol_library(
|
|
library_path=params.get("libraryPath", ""),
|
|
library_name=params.get("libraryName"),
|
|
description=params.get("description", ""),
|
|
scope=params.get("scope", "project"),
|
|
project_path=params.get("projectPath"),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"register_symbol_library error: {e}")
|
|
return {"success": False, "error": str(e)}
|
|
|
|
def _handle_export_schematic_pdf(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Export schematic to PDF"""
|
|
logger.info("Exporting schematic to PDF")
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
output_path = params.get("outputPath")
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "Schematic path is required"}
|
|
if not output_path:
|
|
return {"success": False, "message": "Output path is required"}
|
|
|
|
if not os.path.exists(schematic_path):
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
import subprocess
|
|
|
|
cmd = [
|
|
"kicad-cli",
|
|
"sch",
|
|
"export",
|
|
"pdf",
|
|
"--output",
|
|
output_path,
|
|
schematic_path,
|
|
]
|
|
|
|
if params.get("blackAndWhite"):
|
|
cmd.insert(-1, "--black-and-white")
|
|
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|
|
|
if result.returncode == 0:
|
|
return {"success": True, "file": {"path": output_path}}
|
|
else:
|
|
return {
|
|
"success": False,
|
|
"message": f"kicad-cli failed: {result.stderr}",
|
|
}
|
|
|
|
except FileNotFoundError:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
except Exception as e:
|
|
logger.error(f"Error exporting schematic to PDF: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_add_schematic_net_label(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a net label to schematic using WireManager.
|
|
|
|
When componentRef and pinNumber are supplied the label is placed at the
|
|
exact pin endpoint retrieved via PinLocator, ignoring the provided
|
|
position. The response includes the actual coordinates used and
|
|
whether the label landed on a pin endpoint.
|
|
"""
|
|
logger.info("Adding net label to schematic")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.wire_manager import WireManager
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
net_name = params.get("netName")
|
|
position = params.get("position")
|
|
label_type = params.get("labelType", "label")
|
|
orientation = params.get("orientation", 0)
|
|
component_ref = params.get("componentRef")
|
|
pin_number = params.get("pinNumber")
|
|
|
|
if not all([schematic_path, net_name]):
|
|
return {
|
|
"success": False,
|
|
"message": "Missing required parameters: schematicPath, netName",
|
|
}
|
|
|
|
snapped_to_pin: Optional[Dict[str, Any]] = None
|
|
|
|
if component_ref and pin_number:
|
|
# Snap position to exact pin endpoint using PinLocator
|
|
from commands.pin_locator import PinLocator
|
|
|
|
locator = PinLocator()
|
|
pin_loc = locator.get_pin_location(
|
|
Path(schematic_path), component_ref, str(pin_number)
|
|
)
|
|
if pin_loc is None:
|
|
return {
|
|
"success": False,
|
|
"message": (
|
|
f"Could not locate pin {pin_number} on {component_ref}. "
|
|
"Check the reference and pin number."
|
|
),
|
|
}
|
|
position = pin_loc
|
|
snapped_to_pin = {"component": component_ref, "pin": str(pin_number)}
|
|
logger.info(
|
|
f"Snapped label '{net_name}' to pin {component_ref}/{pin_number} at {position}"
|
|
)
|
|
elif position is None:
|
|
return {
|
|
"success": False,
|
|
"message": (
|
|
"Missing position. Either provide position [x, y] or "
|
|
"componentRef + pinNumber to snap to a pin endpoint."
|
|
),
|
|
}
|
|
|
|
# Collect existing net names BEFORE adding the new label so we can
|
|
# detect case-mismatch collisions against pre-existing nets only.
|
|
existing_net_names: List[str] = []
|
|
try:
|
|
pre_schematic = SchematicManager.load_schematic(schematic_path)
|
|
if pre_schematic is not None:
|
|
if hasattr(pre_schematic, "label"):
|
|
for lbl in pre_schematic.label:
|
|
if hasattr(lbl, "value"):
|
|
existing_net_names.append(lbl.value)
|
|
if hasattr(pre_schematic, "global_label"):
|
|
for lbl in pre_schematic.global_label:
|
|
if hasattr(lbl, "value"):
|
|
existing_net_names.append(lbl.value)
|
|
except Exception:
|
|
# Non-fatal: if we can't read existing nets, skip the warning
|
|
existing_net_names = []
|
|
|
|
# Use WireManager for S-expression manipulation
|
|
success = WireManager.add_label(
|
|
Path(schematic_path),
|
|
net_name,
|
|
position,
|
|
label_type=label_type,
|
|
orientation=orientation,
|
|
)
|
|
|
|
if not success:
|
|
return {"success": False, "message": "Failed to add net label"}
|
|
|
|
# Compute case-mismatch warnings against pre-existing net names.
|
|
# A collision is: existing name != new name, but lowercases match.
|
|
new_name_lower = net_name.lower()
|
|
case_warnings: List[str] = [
|
|
f"Net '{existing}' already exists — label '{net_name}' may be a case mismatch."
|
|
for existing in existing_net_names
|
|
if existing.lower() == new_name_lower and existing != net_name
|
|
]
|
|
|
|
response: Dict[str, Any] = {
|
|
"success": True,
|
|
"message": f"Added net label '{net_name}' at {position}",
|
|
"actual_position": position,
|
|
}
|
|
if snapped_to_pin:
|
|
response["snapped_to_pin"] = snapped_to_pin
|
|
response["message"] = (
|
|
f"Added net label '{net_name}' at exact pin endpoint "
|
|
f"{component_ref}/{pin_number} ({position[0]}, {position[1]})"
|
|
)
|
|
if case_warnings:
|
|
response["case_warnings"] = case_warnings
|
|
return response
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error adding net label: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {
|
|
"success": False,
|
|
"message": str(e),
|
|
"errorDetails": traceback.format_exc(),
|
|
}
|
|
|
|
def _handle_add_no_connect(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a no-connect flag (X marker) to an unconnected pin in the schematic."""
|
|
logger.info("Adding no-connect flag to schematic")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.pin_locator import PinLocator
|
|
from commands.wire_manager import WireManager
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
position = params.get("position")
|
|
component_ref = params.get("componentRef")
|
|
pin_number = params.get("pinNumber")
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
# Snap to pin endpoint when componentRef + pinNumber are provided
|
|
snapped_to_pin = None
|
|
if component_ref and pin_number is not None:
|
|
locator = PinLocator()
|
|
pin_loc = locator.get_pin_location(
|
|
Path(schematic_path), component_ref, str(pin_number)
|
|
)
|
|
if pin_loc is None:
|
|
return {
|
|
"success": False,
|
|
"message": f"Could not locate pin {pin_number} on {component_ref}",
|
|
}
|
|
position = pin_loc
|
|
snapped_to_pin = {"component": component_ref, "pin": str(pin_number)}
|
|
elif position is None:
|
|
return {
|
|
"success": False,
|
|
"message": "Provide either position [x, y] or componentRef + pinNumber",
|
|
}
|
|
|
|
success = WireManager.add_no_connect(Path(schematic_path), position)
|
|
if success:
|
|
result = {
|
|
"success": True,
|
|
"message": f"Added no-connect flag at {position}",
|
|
"actual_position": position,
|
|
}
|
|
if snapped_to_pin:
|
|
result["snapped_to_pin"] = snapped_to_pin
|
|
return result
|
|
else:
|
|
return {"success": False, "message": "Failed to add no-connect flag"}
|
|
|
|
except Exception as e:
|
|
import traceback
|
|
|
|
logger.error(f"Error adding no-connect: {e}")
|
|
return {
|
|
"success": False,
|
|
"message": str(e),
|
|
"errorDetails": traceback.format_exc(),
|
|
}
|
|
|
|
def _handle_connect_to_net(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Connect a component pin to a named net using wire stub and label,
|
|
and also assign the net to the corresponding pad on the PCB board so
|
|
that save_project persists the net (pcbnew.SaveBoard only writes nets
|
|
that are referenced by at least one board element).
|
|
"""
|
|
logger.info("Connecting component pin to net")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
component_ref = params.get("componentRef")
|
|
pin_name = params.get("pinName")
|
|
net_name = params.get("netName")
|
|
|
|
if not all([schematic_path, component_ref, pin_name, net_name]):
|
|
return {"success": False, "message": "Missing required parameters"}
|
|
|
|
# Use ConnectionManager with new WireManager integration
|
|
result = ConnectionManager.connect_to_net(
|
|
Path(schematic_path), component_ref, pin_name, net_name
|
|
)
|
|
|
|
# Also assign the net to the pad on the PCB board
|
|
if self.board and isinstance(result, dict) and result.get("success"):
|
|
try:
|
|
if self._assign_net_to_pad(component_ref, pin_name, net_name):
|
|
msg = result.get("message", "")
|
|
result["message"] = (msg + " (PCB pad also updated)").strip()
|
|
except Exception as pcb_err:
|
|
logger.warning(f"Could not assign net to PCB pad: {pcb_err}")
|
|
|
|
return result
|
|
except Exception as e:
|
|
logger.error(f"Error connecting to net: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {
|
|
"success": False,
|
|
"message": str(e),
|
|
"errorDetails": traceback.format_exc(),
|
|
}
|
|
|
|
def _handle_connect_passthrough(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Connect all pins of source connector to matching pins of target connector"""
|
|
logger.info("Connecting passthrough between two connectors")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
source_ref = params.get("sourceRef")
|
|
target_ref = params.get("targetRef")
|
|
net_prefix = params.get("netPrefix", "PIN")
|
|
pin_offset = int(params.get("pinOffset", 0))
|
|
|
|
if not all([schematic_path, source_ref, target_ref]):
|
|
return {
|
|
"success": False,
|
|
"message": "Missing required parameters: schematicPath, sourceRef, targetRef",
|
|
}
|
|
|
|
result = ConnectionManager.connect_passthrough(
|
|
Path(schematic_path), source_ref, target_ref, net_prefix, pin_offset
|
|
)
|
|
|
|
# Also assign nets to PCB pads for each successfully connected pin
|
|
pcb_assigned = 0
|
|
if self.board:
|
|
import re as _re
|
|
|
|
for conn_info in result.get("connected", []):
|
|
# Expected format: "{src_ref}/{pin} <-> {tgt_ref}/{pin} [{net}]"
|
|
try:
|
|
parts = conn_info.split(" <-> ")
|
|
if len(parts) != 2:
|
|
continue
|
|
src_part = parts[0]
|
|
rest = parts[1]
|
|
bracket_match = _re.search(r"\[(.+)\]", rest)
|
|
tgt_part = rest.split(" [")[0] if " [" in rest else rest
|
|
net_name = bracket_match.group(1) if bracket_match else None
|
|
if not net_name:
|
|
continue
|
|
|
|
src_ref_pin = src_part.split("/")
|
|
tgt_ref_pin = tgt_part.split("/")
|
|
if len(src_ref_pin) == 2 and self._assign_net_to_pad(
|
|
src_ref_pin[0], src_ref_pin[1], net_name
|
|
):
|
|
pcb_assigned += 1
|
|
if len(tgt_ref_pin) == 2 and self._assign_net_to_pad(
|
|
tgt_ref_pin[0], tgt_ref_pin[1], net_name
|
|
):
|
|
pcb_assigned += 1
|
|
except Exception as parse_err:
|
|
logger.debug(
|
|
f"Could not parse passthrough result for PCB assignment: {parse_err}"
|
|
)
|
|
|
|
n_ok = len(result["connected"])
|
|
n_fail = len(result["failed"])
|
|
msg = f"Passthrough complete: {n_ok} connected, {n_fail} failed"
|
|
if pcb_assigned:
|
|
msg += f" ({pcb_assigned} PCB pads updated)"
|
|
return {
|
|
"success": n_fail == 0,
|
|
"message": msg,
|
|
"connected": result["connected"],
|
|
"failed": result["failed"],
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error in connect_passthrough: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _assign_net_to_pad(self, component_ref: str, pin_name: str, net_name: str) -> bool:
|
|
"""Assign a net to a specific pad on the PCB board.
|
|
|
|
Ensures the net exists on the board and sets it on the matching pad.
|
|
Needed because pcbnew.SaveBoard() drops nets that are not referenced
|
|
by any board element (pad/track/via/zone).
|
|
Returns True if the pad was found and updated.
|
|
"""
|
|
board = self.board
|
|
if not board:
|
|
return False
|
|
|
|
netinfo = board.GetNetInfo()
|
|
nets_map = netinfo.NetsByName()
|
|
if not nets_map.has_key(net_name):
|
|
net_item = pcbnew.NETINFO_ITEM(board, net_name)
|
|
board.Add(net_item)
|
|
netinfo = board.GetNetInfo()
|
|
nets_map = netinfo.NetsByName()
|
|
|
|
if not nets_map.has_key(net_name):
|
|
logger.warning(f"Net '{net_name}' could not be created on board")
|
|
return False
|
|
|
|
net_obj = nets_map[net_name]
|
|
|
|
for fp in board.GetFootprints():
|
|
if fp.GetReference() == component_ref:
|
|
for pad in fp.Pads():
|
|
if str(pad.GetNumber()) == str(pin_name):
|
|
pad.SetNet(net_obj)
|
|
logger.info(
|
|
f"Assigned net '{net_name}' to pad {component_ref}/{pin_name} on PCB"
|
|
)
|
|
return True
|
|
logger.warning(f"Pad '{pin_name}' not found on footprint '{component_ref}'")
|
|
return False
|
|
|
|
logger.warning(f"Footprint '{component_ref}' not found on board")
|
|
return False
|
|
|
|
def _handle_get_schematic_pin_locations(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Return exact pin endpoint coordinates for a schematic component"""
|
|
logger.info("Getting schematic pin locations")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.pin_locator import PinLocator
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
reference = params.get("reference")
|
|
|
|
if not all([schematic_path, reference]):
|
|
return {
|
|
"success": False,
|
|
"message": "Missing required parameters: schematicPath, reference",
|
|
}
|
|
|
|
locator = PinLocator()
|
|
all_pins = locator.get_all_symbol_pins(Path(schematic_path), reference)
|
|
|
|
if not all_pins:
|
|
return {
|
|
"success": False,
|
|
"message": f"No pins found for {reference} — check reference and schematic path",
|
|
}
|
|
|
|
# Enrich with pin names and angles from the symbol definition
|
|
pins_def = (
|
|
locator.get_symbol_pins(
|
|
Path(schematic_path),
|
|
locator._get_lib_id(Path(schematic_path), reference),
|
|
)
|
|
if hasattr(locator, "_get_lib_id")
|
|
else {}
|
|
)
|
|
|
|
result = {}
|
|
for pin_num, coords in all_pins.items():
|
|
entry = {"x": coords[0], "y": coords[1]}
|
|
if pin_num in pins_def:
|
|
entry["name"] = pins_def[pin_num].get("name", pin_num)
|
|
entry["angle"] = (
|
|
locator.get_pin_angle(Path(schematic_path), reference, pin_num) or 0
|
|
)
|
|
result[pin_num] = entry
|
|
|
|
return {"success": True, "reference": reference, "pins": result}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error getting pin locations: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_get_schematic_view(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Get a rasterised image of the schematic (SVG export → optional PNG conversion)"""
|
|
logger.info("Getting schematic view")
|
|
import base64
|
|
import subprocess
|
|
import tempfile
|
|
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path or not os.path.exists(schematic_path):
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
fmt = params.get("format", "png")
|
|
width = params.get("width", 1200)
|
|
height = params.get("height", 900)
|
|
|
|
# Step 1: Export schematic to SVG via kicad-cli
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
svg_path = os.path.join(tmpdir, "schematic.svg")
|
|
cmd = [
|
|
"kicad-cli",
|
|
"sch",
|
|
"export",
|
|
"svg",
|
|
"--output",
|
|
tmpdir,
|
|
"--no-background-color",
|
|
schematic_path,
|
|
]
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|
|
|
if result.returncode != 0:
|
|
return {
|
|
"success": False,
|
|
"message": f"kicad-cli SVG export failed: {result.stderr}",
|
|
}
|
|
|
|
# kicad-cli may name the file after the schematic, find it
|
|
import glob
|
|
|
|
svg_files = glob.glob(os.path.join(tmpdir, "*.svg"))
|
|
if not svg_files:
|
|
return {
|
|
"success": False,
|
|
"message": "No SVG file produced by kicad-cli",
|
|
}
|
|
svg_path = svg_files[0]
|
|
|
|
if fmt == "svg":
|
|
with open(svg_path, "r", encoding="utf-8") as f:
|
|
svg_data = f.read()
|
|
return {"success": True, "imageData": svg_data, "format": "svg"}
|
|
|
|
# Step 2: Convert SVG to PNG using cairosvg
|
|
try:
|
|
from cairosvg import svg2png
|
|
except ImportError:
|
|
# Fallback: return SVG data with a note
|
|
with open(svg_path, "r", encoding="utf-8") as f:
|
|
svg_data = f.read()
|
|
return {
|
|
"success": True,
|
|
"imageData": svg_data,
|
|
"format": "svg",
|
|
"message": "cairosvg not installed — returning SVG instead of PNG. Install with: pip install cairosvg",
|
|
}
|
|
|
|
png_data = svg2png(url=svg_path, output_width=width, output_height=height)
|
|
|
|
return {
|
|
"success": True,
|
|
"imageData": base64.b64encode(png_data).decode("utf-8"),
|
|
"format": "png",
|
|
"width": width,
|
|
"height": height,
|
|
}
|
|
|
|
except FileNotFoundError:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
except Exception as e:
|
|
logger.error(f"Error getting schematic view: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_list_schematic_components(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List all components in a schematic"""
|
|
logger.info("Listing schematic components")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.pin_locator import PinLocator
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
# Optional filters
|
|
filter_params = params.get("filter", {})
|
|
lib_id_filter = filter_params.get("libId", "")
|
|
ref_prefix_filter = filter_params.get("referencePrefix", "")
|
|
|
|
locator = PinLocator()
|
|
components = []
|
|
|
|
for symbol in schematic.symbol:
|
|
if not hasattr(symbol.property, "Reference"):
|
|
continue
|
|
ref = symbol.property.Reference.value
|
|
# Skip template symbols
|
|
if ref.startswith("_TEMPLATE"):
|
|
continue
|
|
|
|
lib_id = symbol.lib_id.value if hasattr(symbol, "lib_id") else ""
|
|
|
|
# Apply filters
|
|
if lib_id_filter and lib_id_filter not in lib_id:
|
|
continue
|
|
if ref_prefix_filter and not ref.startswith(ref_prefix_filter):
|
|
continue
|
|
|
|
value = symbol.property.Value.value if hasattr(symbol.property, "Value") else ""
|
|
footprint = (
|
|
symbol.property.Footprint.value if hasattr(symbol.property, "Footprint") else ""
|
|
)
|
|
position = symbol.at.value if hasattr(symbol, "at") else [0, 0, 0]
|
|
uuid_val = symbol.uuid.value if hasattr(symbol, "uuid") else ""
|
|
|
|
comp = {
|
|
"reference": ref,
|
|
"libId": lib_id,
|
|
"value": value,
|
|
"footprint": footprint,
|
|
"position": {"x": float(position[0]), "y": float(position[1])},
|
|
"rotation": float(position[2]) if len(position) > 2 else 0,
|
|
"uuid": str(uuid_val),
|
|
}
|
|
|
|
# Get pins if available
|
|
try:
|
|
all_pins = locator.get_all_symbol_pins(sch_file, ref)
|
|
if all_pins:
|
|
pins_def = locator.get_symbol_pins(sch_file, lib_id) or {}
|
|
pin_list = []
|
|
for pin_num, coords in all_pins.items():
|
|
pin_info = {
|
|
"number": pin_num,
|
|
"position": {"x": coords[0], "y": coords[1]},
|
|
}
|
|
if pin_num in pins_def:
|
|
pin_info["name"] = pins_def[pin_num].get("name", pin_num)
|
|
pin_list.append(pin_info)
|
|
comp["pins"] = pin_list
|
|
except Exception:
|
|
pass # Pin lookup is best-effort
|
|
|
|
components.append(comp)
|
|
|
|
return {"success": True, "components": components, "count": len(components)}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error listing schematic components: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_list_schematic_nets(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List all nets in a schematic with their connections"""
|
|
logger.info("Listing schematic nets")
|
|
try:
|
|
from commands.wire_connectivity import (
|
|
_build_adjacency,
|
|
_discover_sub_sheets,
|
|
_load_sexp,
|
|
_parse_labels_sexp,
|
|
_parse_virtual_connections,
|
|
_parse_wires,
|
|
count_pins_on_net,
|
|
get_connections_for_net,
|
|
)
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
# Collect net names from the top-level sheet using sexpdata.
|
|
# Falls back to kicad-skip's label collections when the file
|
|
# cannot be read (e.g. mocked schematics in unit tests).
|
|
net_names: set = set()
|
|
sexp_loaded = False
|
|
try:
|
|
sexp = _load_sexp(schematic_path)
|
|
sexp_loaded = True
|
|
_, label_to_points = _parse_labels_sexp(sexp)
|
|
net_names.update(label_to_points.keys())
|
|
except Exception as e:
|
|
logger.debug(
|
|
f"Could not parse labels from {schematic_path} via sexp ({e}); "
|
|
"falling back to kicad-skip label collections"
|
|
)
|
|
for attr in ("label", "global_label"):
|
|
if not hasattr(schematic, attr):
|
|
continue
|
|
for label in getattr(schematic, attr):
|
|
if hasattr(label, "value"):
|
|
net_names.add(label.value)
|
|
|
|
# Collect net names from all sub-sheets (only when the parent
|
|
# sheet was readable; fake/mock paths skip recursion entirely).
|
|
if sexp_loaded:
|
|
sub_sheets = _discover_sub_sheets(schematic_path)
|
|
for sub_path in sub_sheets:
|
|
try:
|
|
sub_sexp = _load_sexp(sub_path)
|
|
_, sub_label_to_points = _parse_labels_sexp(sub_sexp)
|
|
net_names.update(sub_label_to_points.keys())
|
|
except Exception as e:
|
|
logger.warning(f"Error reading sub-sheet {sub_path}: {e}")
|
|
|
|
# Pre-build shared wire graph structures for efficiency
|
|
all_wires = _parse_wires(schematic)
|
|
if all_wires:
|
|
adjacency, iu_to_wires = _build_adjacency(all_wires)
|
|
else:
|
|
adjacency, iu_to_wires = [], {}
|
|
point_to_label, label_to_points = _parse_virtual_connections(schematic, schematic_path)
|
|
|
|
nets = []
|
|
for net_name in sorted(net_names):
|
|
connections = get_connections_for_net(schematic, schematic_path, net_name)
|
|
pin_count = count_pins_on_net(
|
|
schematic,
|
|
schematic_path,
|
|
net_name,
|
|
all_wires,
|
|
iu_to_wires,
|
|
adjacency,
|
|
point_to_label,
|
|
label_to_points,
|
|
)
|
|
nets.append(
|
|
{
|
|
"name": net_name,
|
|
"connections": connections,
|
|
"connected_pin_count": pin_count,
|
|
}
|
|
)
|
|
|
|
return {"success": True, "nets": nets, "count": len(nets)}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error listing schematic nets: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_list_schematic_wires(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List all wires in a schematic"""
|
|
logger.info("Listing schematic wires")
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
wires = []
|
|
if hasattr(schematic, "wire"):
|
|
for wire in schematic.wire:
|
|
if hasattr(wire, "pts") and hasattr(wire.pts, "xy"):
|
|
points = []
|
|
for point in wire.pts.xy:
|
|
if hasattr(point, "value"):
|
|
points.append(
|
|
{
|
|
"x": float(point.value[0]),
|
|
"y": float(point.value[1]),
|
|
}
|
|
)
|
|
|
|
if len(points) >= 2:
|
|
wires.append(
|
|
{
|
|
"start": points[0],
|
|
"end": points[-1],
|
|
}
|
|
)
|
|
|
|
return {"success": True, "wires": wires, "count": len(wires)}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error listing schematic wires: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_list_schematic_labels(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List all net labels and power flags in a schematic"""
|
|
logger.info("Listing schematic labels")
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
net_name = params.get("netName")
|
|
label_type = params.get("labelType")
|
|
|
|
_valid_label_types = {"net", "global", "power"}
|
|
if label_type is not None and label_type not in _valid_label_types:
|
|
return {"success": False, "message": "labelType must be one of: net, global, power"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
labels = []
|
|
|
|
# Regular labels
|
|
if hasattr(schematic, "label"):
|
|
for label in schematic.label:
|
|
if hasattr(label, "value"):
|
|
pos = (
|
|
label.at.value
|
|
if hasattr(label, "at") and hasattr(label.at, "value")
|
|
else [0, 0]
|
|
)
|
|
labels.append(
|
|
{
|
|
"name": label.value,
|
|
"type": "net",
|
|
"position": {"x": float(pos[0]), "y": float(pos[1])},
|
|
}
|
|
)
|
|
|
|
# Global labels
|
|
if hasattr(schematic, "global_label"):
|
|
for label in schematic.global_label:
|
|
if hasattr(label, "value"):
|
|
pos = (
|
|
label.at.value
|
|
if hasattr(label, "at") and hasattr(label.at, "value")
|
|
else [0, 0]
|
|
)
|
|
labels.append(
|
|
{
|
|
"name": label.value,
|
|
"type": "global",
|
|
"position": {"x": float(pos[0]), "y": float(pos[1])},
|
|
}
|
|
)
|
|
|
|
# Power symbols (components with power flag)
|
|
if hasattr(schematic, "symbol"):
|
|
for symbol in schematic.symbol:
|
|
if not hasattr(symbol.property, "Reference"):
|
|
continue
|
|
ref = symbol.property.Reference.value
|
|
if ref.startswith("_TEMPLATE"):
|
|
continue
|
|
if not ref.startswith("#PWR"):
|
|
continue
|
|
value = (
|
|
symbol.property.Value.value if hasattr(symbol.property, "Value") else ref
|
|
)
|
|
pos = symbol.at.value if hasattr(symbol, "at") else [0, 0, 0]
|
|
labels.append(
|
|
{
|
|
"name": value,
|
|
"type": "power",
|
|
"position": {"x": float(pos[0]), "y": float(pos[1])},
|
|
}
|
|
)
|
|
|
|
# Apply filters
|
|
if net_name is not None:
|
|
labels = [lbl for lbl in labels if lbl["name"] == net_name]
|
|
if label_type is not None:
|
|
labels = [lbl for lbl in labels if lbl["type"] == label_type]
|
|
|
|
return {"success": True, "labels": labels, "count": len(labels)}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error listing schematic labels: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_move_schematic_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Move a schematic component to a new position, dragging connected wires."""
|
|
logger.info("Moving schematic component")
|
|
try:
|
|
from commands.wire_dragger import WireDragger
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
reference = params.get("reference")
|
|
position = params.get("position", {})
|
|
new_x = position.get("x")
|
|
new_y = position.get("y")
|
|
preserve_wires = params.get("preserveWires", True)
|
|
|
|
if not schematic_path or not reference:
|
|
return {
|
|
"success": False,
|
|
"message": "schematicPath and reference are required",
|
|
}
|
|
if new_x is None or new_y is None:
|
|
return {
|
|
"success": False,
|
|
"message": "position with x and y is required",
|
|
}
|
|
|
|
with open(schematic_path, "r", encoding="utf-8") as f:
|
|
sch_data = sexpdata.loads(f.read())
|
|
|
|
# Find symbol and record old position
|
|
found = WireDragger.find_symbol(sch_data, reference)
|
|
if found is None:
|
|
return {"success": False, "message": f"Component {reference} not found"}
|
|
_, old_x, old_y = found[0], found[1], found[2]
|
|
old_position = {"x": old_x, "y": old_y}
|
|
|
|
drag_summary = {}
|
|
if preserve_wires:
|
|
# Compute pin world positions before and after the move
|
|
pin_positions = WireDragger.compute_pin_positions(
|
|
sch_data, reference, float(new_x), float(new_y)
|
|
)
|
|
# Build old→new coordinate map (deduplicate coincident pins)
|
|
old_to_new = {}
|
|
for _pin, (old_xy, new_xy) in pin_positions.items():
|
|
if old_xy in old_to_new:
|
|
logger.warning(
|
|
f"move_schematic_component: pin {_pin!r} of {reference!r} "
|
|
f"shares old position {old_xy} with another pin; "
|
|
f"keeping first entry, skipping duplicate"
|
|
)
|
|
continue
|
|
old_to_new[old_xy] = new_xy
|
|
|
|
drag_summary = WireDragger.drag_wires(sch_data, old_to_new)
|
|
|
|
# Synthesize wires for touching-pin connections after dragging,
|
|
# so drag_wires doesn't accidentally move and collapse the new wire.
|
|
wires_synthesized = WireDragger.synthesize_touching_pin_wires(
|
|
sch_data, reference, pin_positions
|
|
)
|
|
drag_summary["wires_synthesized"] = wires_synthesized
|
|
|
|
# Update symbol position
|
|
WireDragger.update_symbol_position(sch_data, reference, float(new_x), float(new_y))
|
|
|
|
WireManager.sync_junctions(sch_data)
|
|
|
|
with open(schematic_path, "w", encoding="utf-8") as f:
|
|
f.write(sexpdata.dumps(sch_data))
|
|
|
|
return {
|
|
"success": True,
|
|
"oldPosition": old_position,
|
|
"newPosition": {"x": new_x, "y": new_y},
|
|
"wiresMoved": drag_summary.get("endpoints_moved", 0),
|
|
"wiresRemoved": drag_summary.get("wires_removed", 0),
|
|
"wiresSynthesized": drag_summary.get("wires_synthesized", 0),
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error moving schematic component: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_rotate_schematic_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Rotate and/or mirror a schematic component, dragging connected wires."""
|
|
logger.info("Rotating schematic component")
|
|
try:
|
|
import sexpdata as _sexpdata
|
|
from commands.wire_dragger import WireDragger
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
reference = params.get("reference")
|
|
angle = params.get("angle", 0)
|
|
mirror = params.get("mirror") # "x", "y", or None
|
|
|
|
if not schematic_path or not reference:
|
|
return {
|
|
"success": False,
|
|
"message": "schematicPath and reference are required",
|
|
}
|
|
|
|
with open(schematic_path, "r", encoding="utf-8") as f:
|
|
sch_data = _sexpdata.loads(f.read())
|
|
|
|
found = WireDragger.find_symbol(sch_data, reference)
|
|
if found is None:
|
|
return {"success": False, "message": f"Component {reference} not found"}
|
|
|
|
# Determine new mirror state: explicit param overrides; None preserves existing
|
|
_, _, _, _, _, old_mirror_x, old_mirror_y = found
|
|
if mirror is None:
|
|
new_mirror_x = old_mirror_x
|
|
new_mirror_y = old_mirror_y
|
|
effective_mirror = "x" if old_mirror_x else ("y" if old_mirror_y else None)
|
|
else:
|
|
new_mirror_x = mirror == "x"
|
|
new_mirror_y = mirror == "y"
|
|
effective_mirror = mirror
|
|
|
|
# Compute pin world positions before and after the transform
|
|
pin_positions = WireDragger.compute_pin_positions_for_rotation(
|
|
sch_data, reference, float(angle), new_mirror_x, new_mirror_y
|
|
)
|
|
|
|
# Build old→new map (skip pins that don't move)
|
|
old_to_new = {}
|
|
for _pin, (old_xy, new_xy) in pin_positions.items():
|
|
if old_xy == new_xy:
|
|
continue
|
|
if old_xy in old_to_new:
|
|
logger.warning(
|
|
f"rotate: pin {_pin!r} of {reference!r} shares old position "
|
|
f"{old_xy} with another pin; skipping duplicate"
|
|
)
|
|
continue
|
|
old_to_new[old_xy] = new_xy
|
|
|
|
# Drag connected wires to follow pins
|
|
drag_summary = WireDragger.drag_wires(sch_data, old_to_new)
|
|
|
|
# Update the symbol's rotation and mirror token in sexpdata
|
|
WireDragger.update_symbol_rotation_mirror(
|
|
sch_data, reference, float(angle), effective_mirror
|
|
)
|
|
|
|
WireManager.sync_junctions(sch_data)
|
|
|
|
with open(schematic_path, "w", encoding="utf-8") as f:
|
|
f.write(_sexpdata.dumps(sch_data))
|
|
|
|
return {
|
|
"success": True,
|
|
"reference": reference,
|
|
"angle": angle,
|
|
"mirror": effective_mirror,
|
|
"wiresMoved": drag_summary.get("endpoints_moved", 0),
|
|
"wiresRemoved": drag_summary.get("wires_removed", 0),
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error rotating schematic component: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_annotate_schematic(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Annotate unannotated components in schematic (R? -> R1, R2, ...)"""
|
|
logger.info("Annotating schematic")
|
|
try:
|
|
import re
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
# Collect existing references by prefix
|
|
existing_refs = {} # prefix -> set of numbers
|
|
unannotated = [] # (symbol, prefix)
|
|
|
|
for symbol in schematic.symbol:
|
|
if not hasattr(symbol.property, "Reference"):
|
|
continue
|
|
ref = symbol.property.Reference.value
|
|
if ref.startswith("_TEMPLATE"):
|
|
continue
|
|
|
|
# Split reference into prefix and number
|
|
match = re.match(r"^([A-Za-z_]+)(\d+)$", ref)
|
|
if match:
|
|
prefix = match.group(1)
|
|
num = int(match.group(2))
|
|
if prefix not in existing_refs:
|
|
existing_refs[prefix] = set()
|
|
existing_refs[prefix].add(num)
|
|
elif ref.endswith("?"):
|
|
prefix = ref[:-1]
|
|
unannotated.append((symbol, prefix))
|
|
|
|
if not unannotated:
|
|
return {
|
|
"success": True,
|
|
"annotated": [],
|
|
"message": "All components already annotated",
|
|
}
|
|
|
|
annotated = []
|
|
for symbol, prefix in unannotated:
|
|
if prefix not in existing_refs:
|
|
existing_refs[prefix] = set()
|
|
|
|
# Find next available number
|
|
next_num = 1
|
|
while next_num in existing_refs[prefix]:
|
|
next_num += 1
|
|
|
|
old_ref = symbol.property.Reference.value
|
|
new_ref = f"{prefix}{next_num}"
|
|
symbol.setAllReferences(new_ref)
|
|
existing_refs[prefix].add(next_num)
|
|
|
|
uuid_val = str(symbol.uuid.value) if hasattr(symbol, "uuid") else ""
|
|
annotated.append(
|
|
{
|
|
"uuid": uuid_val,
|
|
"oldReference": old_ref,
|
|
"newReference": new_ref,
|
|
}
|
|
)
|
|
|
|
SchematicManager.save_schematic(schematic, schematic_path)
|
|
return {"success": True, "annotated": annotated}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error annotating schematic: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_delete_schematic_wire(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Delete a wire from the schematic matching start/end points"""
|
|
logger.info("Deleting schematic wire")
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
start = params.get("start", {})
|
|
end = params.get("end", {})
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
from pathlib import Path
|
|
|
|
from commands.wire_manager import WireManager
|
|
|
|
start_point = [start.get("x", 0), start.get("y", 0)]
|
|
end_point = [end.get("x", 0), end.get("y", 0)]
|
|
|
|
deleted = WireManager.delete_wire(Path(schematic_path), start_point, end_point)
|
|
if deleted:
|
|
return {"success": True}
|
|
else:
|
|
return {"success": False, "message": "No matching wire found"}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error deleting schematic wire: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_delete_schematic_net_label(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Delete a net label from the schematic"""
|
|
logger.info("Deleting schematic net label")
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
net_name = params.get("netName")
|
|
position = params.get("position")
|
|
|
|
if not schematic_path or not net_name:
|
|
return {
|
|
"success": False,
|
|
"message": "schematicPath and netName are required",
|
|
}
|
|
|
|
from pathlib import Path
|
|
|
|
from commands.wire_manager import WireManager
|
|
|
|
pos_list = None
|
|
if position:
|
|
pos_list = [position.get("x", 0), position.get("y", 0)]
|
|
|
|
deleted = WireManager.delete_label(Path(schematic_path), net_name, pos_list)
|
|
if deleted:
|
|
return {"success": True}
|
|
else:
|
|
return {"success": False, "message": f"Label '{net_name}' not found"}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error deleting schematic net label: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_move_schematic_net_label(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Move a net label to a new position in the schematic."""
|
|
logger.info("Moving schematic net label")
|
|
try:
|
|
import sexpdata as _sexpdata
|
|
from sexpdata import Symbol
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
net_name = params.get("netName")
|
|
new_position = params.get("newPosition", {})
|
|
new_x = new_position.get("x")
|
|
new_y = new_position.get("y")
|
|
current_position = params.get("currentPosition")
|
|
label_type = params.get("labelType")
|
|
|
|
if not schematic_path or not net_name:
|
|
return {"success": False, "message": "schematicPath and netName are required"}
|
|
if new_x is None or new_y is None:
|
|
return {"success": False, "message": "newPosition with x and y is required"}
|
|
|
|
_valid_types = {"label", "global_label", "hierarchical_label"}
|
|
if label_type is not None and label_type not in _valid_types:
|
|
return {
|
|
"success": False,
|
|
"message": f"labelType must be one of: {', '.join(sorted(_valid_types))}",
|
|
}
|
|
|
|
_SYM_AT = Symbol("at")
|
|
target_syms = (
|
|
{Symbol(label_type)}
|
|
if label_type is not None
|
|
else {Symbol(t) for t in _valid_types}
|
|
)
|
|
|
|
TOLERANCE = 0.5
|
|
|
|
with open(schematic_path, "r", encoding="utf-8") as f:
|
|
sch_data = _sexpdata.loads(f.read())
|
|
|
|
for item in sch_data:
|
|
if not (isinstance(item, list) and len(item) >= 2 and item[0] in target_syms):
|
|
continue
|
|
if item[1] != net_name:
|
|
continue
|
|
|
|
at_idx = next(
|
|
(
|
|
j
|
|
for j, p in enumerate(item)
|
|
if isinstance(p, list) and len(p) >= 3 and p[0] == _SYM_AT
|
|
),
|
|
None,
|
|
)
|
|
if at_idx is None:
|
|
continue
|
|
|
|
at_entry = item[at_idx]
|
|
old_x, old_y = float(at_entry[1]), float(at_entry[2])
|
|
|
|
if current_position is not None:
|
|
cx = current_position.get("x", 0)
|
|
cy = current_position.get("y", 0)
|
|
if not (abs(old_x - cx) < TOLERANCE and abs(old_y - cy) < TOLERANCE):
|
|
continue
|
|
|
|
rotation = at_entry[3] if len(at_entry) > 3 else 0
|
|
item[at_idx] = [_SYM_AT, float(new_x), float(new_y), rotation]
|
|
|
|
with open(schematic_path, "w", encoding="utf-8") as f:
|
|
f.write(_sexpdata.dumps(sch_data))
|
|
|
|
return {
|
|
"success": True,
|
|
"oldPosition": {"x": old_x, "y": old_y},
|
|
"newPosition": {"x": float(new_x), "y": float(new_y)},
|
|
}
|
|
|
|
return {"success": False, "message": f"Label '{net_name}' not found"}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error moving schematic net label: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_export_schematic_svg(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Export schematic to SVG using kicad-cli"""
|
|
logger.info("Exporting schematic SVG")
|
|
import glob
|
|
import shutil
|
|
import subprocess
|
|
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
output_path = params.get("outputPath")
|
|
|
|
if not schematic_path or not output_path:
|
|
return {
|
|
"success": False,
|
|
"message": "schematicPath and outputPath are required",
|
|
}
|
|
|
|
if not os.path.exists(schematic_path):
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
# kicad-cli's --output flag for SVG export expects a directory, not a file path.
|
|
# The output file is auto-named based on the schematic name.
|
|
output_dir = os.path.dirname(output_path)
|
|
if not output_dir:
|
|
output_dir = "."
|
|
|
|
os.makedirs(output_dir, exist_ok=True)
|
|
|
|
cmd = [
|
|
"kicad-cli",
|
|
"sch",
|
|
"export",
|
|
"svg",
|
|
schematic_path,
|
|
"-o",
|
|
output_dir,
|
|
]
|
|
|
|
if params.get("blackAndWhite"):
|
|
cmd.append("--black-and-white")
|
|
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|
|
|
if result.returncode != 0:
|
|
return {
|
|
"success": False,
|
|
"message": f"kicad-cli failed: {result.stderr}",
|
|
}
|
|
|
|
# kicad-cli names the file after the schematic, so find the generated SVG
|
|
svg_files = glob.glob(os.path.join(output_dir, "*.svg"))
|
|
if not svg_files:
|
|
return {
|
|
"success": False,
|
|
"message": "No SVG file produced by kicad-cli",
|
|
}
|
|
|
|
generated_svg = svg_files[0]
|
|
|
|
# Move/rename to the user-specified output path if it differs
|
|
if os.path.abspath(generated_svg) != os.path.abspath(output_path):
|
|
shutil.move(generated_svg, output_path)
|
|
|
|
return {"success": True, "file": {"path": output_path}}
|
|
|
|
except FileNotFoundError:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
except Exception as e:
|
|
logger.error(f"Error exporting schematic SVG: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_get_net_connections(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Get all connections for a named net"""
|
|
logger.info("Getting net connections")
|
|
try:
|
|
from commands.wire_connectivity import get_connections_for_net
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
net_name = params.get("netName")
|
|
|
|
if not all([schematic_path, net_name]):
|
|
return {"success": False, "message": "Missing required parameters"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
connections = get_connections_for_net(schematic, schematic_path, net_name)
|
|
return {"success": True, "connections": connections}
|
|
except Exception as e:
|
|
logger.error(f"Error getting net connections: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_get_wire_connections(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Find net name and all component pins reachable from a point or component pin."""
|
|
logger.info("Getting wire connections")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.pin_locator import PinLocator
|
|
from commands.wire_connectivity import get_wire_connections
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "Missing required parameter: schematicPath"}
|
|
|
|
reference = params.get("reference")
|
|
pin = params.get("pin")
|
|
x = params.get("x")
|
|
y = params.get("y")
|
|
|
|
has_ref_pin = reference is not None and pin is not None
|
|
has_coords = x is not None and y is not None
|
|
|
|
if has_ref_pin and has_coords:
|
|
return {
|
|
"success": False,
|
|
"message": "Supply either {reference, pin} or {x, y}, not both",
|
|
}
|
|
|
|
if not has_ref_pin and not has_coords:
|
|
if reference is not None or pin is not None:
|
|
return {
|
|
"success": False,
|
|
"message": "Both reference and pin are required together",
|
|
}
|
|
return {
|
|
"success": False,
|
|
"message": "Must supply either {reference, pin} or {x, y}",
|
|
}
|
|
|
|
if has_ref_pin:
|
|
location = PinLocator().get_pin_location(Path(schematic_path), reference, str(pin))
|
|
if location is None:
|
|
return {
|
|
"success": False,
|
|
"message": f"Pin {pin} not found on {reference}",
|
|
}
|
|
x, y = location[0], location[1]
|
|
else:
|
|
try:
|
|
x, y = float(x), float(y)
|
|
except (TypeError, ValueError):
|
|
return {"success": False, "message": "Parameters x and y must be numeric"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
if not hasattr(schematic, "wire"):
|
|
return {"success": False, "message": "Schematic has no wires"}
|
|
|
|
result = get_wire_connections(schematic, schematic_path, x, y)
|
|
if result is None:
|
|
return {
|
|
"success": False,
|
|
"message": f"No wire found at ({x},{y}) — point may not be connected",
|
|
}
|
|
|
|
return {"success": True, **result}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error getting wire connections: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_get_net_at_point(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Return the net name at a given (x, y) coordinate, or null if none found."""
|
|
logger.info("Getting net at point")
|
|
try:
|
|
from commands.wire_connectivity import get_net_at_point
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "Missing required parameter: schematicPath"}
|
|
|
|
x = params.get("x")
|
|
y = params.get("y")
|
|
if x is None or y is None:
|
|
return {"success": False, "message": "Missing required parameters: x and y"}
|
|
|
|
try:
|
|
x, y = float(x), float(y)
|
|
except (TypeError, ValueError):
|
|
return {"success": False, "message": "Parameters x and y must be numeric"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
result = get_net_at_point(schematic, schematic_path, x, y)
|
|
return {"success": True, **result}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error getting net at point: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_list_schematic_texts(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List all free-form text annotations (SCH_TEXT) in a schematic."""
|
|
logger.info("Listing schematic text annotations")
|
|
try:
|
|
from commands.wire_manager import WireManager
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {"success": False, "message": f"Schematic not found: {schematic_path}"}
|
|
|
|
texts = WireManager.list_texts(sch_file)
|
|
if texts is None:
|
|
return {"success": False, "message": "Failed to parse schematic"}
|
|
|
|
# Optional text filter
|
|
filter_text = params.get("text")
|
|
if filter_text is not None:
|
|
texts = [t for t in texts if filter_text.lower() in t["text"].lower()]
|
|
|
|
return {"success": True, "texts": texts, "count": len(texts)}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error listing schematic texts: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_add_schematic_text(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a free-form text annotation (SCH_TEXT) to a schematic."""
|
|
logger.info("Adding text annotation to schematic")
|
|
try:
|
|
from commands.wire_manager import WireManager
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
text = params.get("text")
|
|
position = params.get("position")
|
|
angle = params.get("angle", 0)
|
|
font_size = params.get("fontSize", 1.27)
|
|
bold = params.get("bold", False)
|
|
italic = params.get("italic", False)
|
|
justify = params.get("justify", "left")
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
if not text:
|
|
return {"success": False, "message": "text is required"}
|
|
if not position or len(position) != 2:
|
|
return {"success": False, "message": "position [x, y] is required"}
|
|
if justify not in ("left", "center", "right"):
|
|
return {"success": False, "message": "justify must be left, center, or right"}
|
|
if font_size <= 0:
|
|
return {"success": False, "message": "fontSize must be positive"}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
success = WireManager.add_text(
|
|
sch_file,
|
|
text,
|
|
position,
|
|
angle=angle,
|
|
font_size=font_size,
|
|
bold=bold,
|
|
italic=italic,
|
|
justify=justify,
|
|
)
|
|
|
|
if success:
|
|
return {
|
|
"success": True,
|
|
"message": f"Added text '{text}' at ({position[0]}, {position[1]})",
|
|
"position": {"x": position[0], "y": position[1]},
|
|
"angle": angle,
|
|
}
|
|
return {"success": False, "message": "Failed to add text annotation"}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error adding schematic text: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_add_schematic_hierarchical_label(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a hierarchical label to a sub-sheet schematic."""
|
|
logger.info("Adding hierarchical label to schematic")
|
|
try:
|
|
from commands.wire_manager import WireManager
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
text = params.get("text")
|
|
position = params.get("position")
|
|
shape = params.get("shape", "bidirectional")
|
|
orientation = params.get("orientation", 0)
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
if not text:
|
|
return {"success": False, "message": "text is required"}
|
|
if not position or len(position) != 2:
|
|
return {"success": False, "message": "position [x, y] is required"}
|
|
if shape not in ("input", "output", "bidirectional"):
|
|
return {
|
|
"success": False,
|
|
"message": "shape must be input, output, or bidirectional",
|
|
}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
success = WireManager.add_hierarchical_label(
|
|
sch_file, text, position, shape=shape, orientation=orientation
|
|
)
|
|
|
|
if success:
|
|
return {
|
|
"success": True,
|
|
"message": (
|
|
f"Added hierarchical_label '{text}' " f"at {position} shape={shape}"
|
|
),
|
|
}
|
|
return {"success": False, "message": "Failed to add hierarchical label"}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error adding hierarchical label: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_add_sheet_pin(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a sheet pin to a sheet block on the parent schematic."""
|
|
logger.info("Adding sheet pin to schematic")
|
|
try:
|
|
from commands.wire_manager import WireManager
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
sheet_name = params.get("sheetName")
|
|
pin_name = params.get("pinName")
|
|
pin_type = params.get("pinType", "bidirectional")
|
|
position = params.get("position")
|
|
orientation = params.get("orientation", 0)
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
if not sheet_name:
|
|
return {"success": False, "message": "sheetName is required"}
|
|
if not pin_name:
|
|
return {"success": False, "message": "pinName is required"}
|
|
if not position or len(position) != 2:
|
|
return {"success": False, "message": "position [x, y] is required"}
|
|
if pin_type not in ("input", "output", "bidirectional"):
|
|
return {
|
|
"success": False,
|
|
"message": "pinType must be input, output, or bidirectional",
|
|
}
|
|
|
|
sch_file = Path(schematic_path)
|
|
if not sch_file.exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found: {schematic_path}",
|
|
}
|
|
|
|
with open(sch_file, "r", encoding="utf-8") as f:
|
|
content = f.read()
|
|
|
|
modified, success = WireManager.add_sheet_pin(
|
|
content,
|
|
sheet_name,
|
|
pin_name,
|
|
pin_type,
|
|
position,
|
|
orientation=orientation,
|
|
)
|
|
|
|
if not success:
|
|
return {
|
|
"success": False,
|
|
"message": f"Sheet '{sheet_name}' not found in {schematic_path}",
|
|
}
|
|
|
|
with open(sch_file, "w", encoding="utf-8") as f:
|
|
f.write(modified)
|
|
|
|
return {
|
|
"success": True,
|
|
"message": (
|
|
f"Added sheet pin '{pin_name}' ({pin_type}) " f"to sheet '{sheet_name}'"
|
|
),
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error adding sheet pin: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_run_erc(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Run Electrical Rules Check on a schematic via kicad-cli"""
|
|
logger.info("Running ERC on schematic")
|
|
import os
|
|
import subprocess
|
|
import tempfile
|
|
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path or not os.path.exists(schematic_path):
|
|
return {
|
|
"success": False,
|
|
"message": "Schematic file not found",
|
|
"errorDetails": f"Path does not exist: {schematic_path}",
|
|
}
|
|
|
|
kicad_cli = self.design_rule_commands._find_kicad_cli()
|
|
if not kicad_cli:
|
|
return {
|
|
"success": False,
|
|
"message": "kicad-cli not found",
|
|
"errorDetails": "Install KiCAD 8.0+ or add kicad-cli to PATH.",
|
|
}
|
|
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as tmp:
|
|
json_output = tmp.name
|
|
|
|
try:
|
|
cmd = [
|
|
kicad_cli,
|
|
"sch",
|
|
"erc",
|
|
"--format",
|
|
"json",
|
|
"--output",
|
|
json_output,
|
|
schematic_path,
|
|
]
|
|
logger.info(f"Running ERC command: {' '.join(cmd)}")
|
|
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
|
|
|
|
# kicad-cli returns non-zero when ERC violations are found —
|
|
# this is normal, not an error. Only fail when no JSON was
|
|
# produced (genuine CLI failure).
|
|
if not os.path.exists(json_output) or os.path.getsize(json_output) == 0:
|
|
logger.error(f"ERC command produced no output: {result.stderr}")
|
|
return {
|
|
"success": False,
|
|
"message": "ERC command failed - no output produced",
|
|
"errorDetails": result.stderr,
|
|
}
|
|
|
|
with open(json_output, "r", encoding="utf-8") as f:
|
|
erc_data = json.load(f)
|
|
|
|
violations = []
|
|
severity_counts = {"error": 0, "warning": 0, "info": 0}
|
|
|
|
# KiCad 9 nests violations under sheets[].violations
|
|
# instead of (or in addition to) the top-level violations
|
|
# array used by KiCad 8.
|
|
all_violations = erc_data.get("violations", [])
|
|
for sheet in erc_data.get("sheets", []):
|
|
all_violations.extend(sheet.get("violations", []))
|
|
|
|
for v in all_violations:
|
|
vseverity = v.get("severity", "error")
|
|
items = v.get("items", [])
|
|
loc = {}
|
|
if items and "pos" in items[0]:
|
|
loc = {
|
|
"x": items[0]["pos"].get("x", 0),
|
|
"y": items[0]["pos"].get("y", 0),
|
|
}
|
|
violations.append(
|
|
{
|
|
"type": v.get("type", "unknown"),
|
|
"severity": vseverity,
|
|
"message": v.get("description", ""),
|
|
"location": loc,
|
|
}
|
|
)
|
|
if vseverity in severity_counts:
|
|
severity_counts[vseverity] += 1
|
|
|
|
return {
|
|
"success": True,
|
|
"message": f"ERC complete: {len(violations)} violation(s)",
|
|
"summary": {
|
|
"total": len(violations),
|
|
"by_severity": severity_counts,
|
|
},
|
|
"violations": violations,
|
|
}
|
|
|
|
finally:
|
|
if os.path.exists(json_output):
|
|
os.unlink(json_output)
|
|
|
|
except subprocess.TimeoutExpired:
|
|
return {"success": False, "message": "ERC timed out after 120 seconds"}
|
|
except Exception as e:
|
|
logger.error(f"Error running ERC: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
# ------------------------------------------------------------------
|
|
# kicad-cli helper shared by netlist handlers
|
|
# ------------------------------------------------------------------
|
|
|
|
@staticmethod
|
|
def _find_kicad_cli_static() -> Optional[str]:
|
|
"""Return path to kicad-cli executable, or None."""
|
|
import platform
|
|
import shutil
|
|
|
|
cli = shutil.which("kicad-cli")
|
|
if cli:
|
|
return cli
|
|
|
|
system = platform.system()
|
|
if system == "Windows":
|
|
candidates = [
|
|
r"C:\Program Files\KiCad\9.0\bin\kicad-cli.exe",
|
|
r"C:\Program Files\KiCad\8.0\bin\kicad-cli.exe",
|
|
r"C:\Program Files (x86)\KiCad\9.0\bin\kicad-cli.exe",
|
|
r"C:\Program Files (x86)\KiCad\8.0\bin\kicad-cli.exe",
|
|
]
|
|
elif system == "Darwin":
|
|
candidates = [
|
|
"/Applications/KiCad/KiCad.app/Contents/MacOS/kicad-cli",
|
|
"/usr/local/bin/kicad-cli",
|
|
]
|
|
else:
|
|
candidates = [
|
|
"/usr/bin/kicad-cli",
|
|
"/usr/local/bin/kicad-cli",
|
|
]
|
|
for path in candidates:
|
|
if os.path.exists(path):
|
|
return path
|
|
return None
|
|
|
|
# ------------------------------------------------------------------
|
|
|
|
def _handle_export_netlist(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Export netlist to a file using kicad-cli."""
|
|
import subprocess
|
|
|
|
logger.info("Exporting netlist via kicad-cli")
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
output_path = params.get("outputPath")
|
|
fmt = params.get("format", "KiCad")
|
|
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
if not output_path:
|
|
return {"success": False, "message": "outputPath is required"}
|
|
if not os.path.exists(schematic_path):
|
|
return {"success": False, "message": f"Schematic not found: {schematic_path}"}
|
|
|
|
kicad_cli = self._find_kicad_cli_static()
|
|
if not kicad_cli:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
|
|
fmt_map = {
|
|
"KiCad": "kicadxml",
|
|
"Spice": "spice",
|
|
"Cadstar": "cadstar",
|
|
"OrcadPCB2": "orcadpcb2",
|
|
}
|
|
cli_format = fmt_map.get(fmt, "kicadxml")
|
|
|
|
os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)
|
|
|
|
cmd = [
|
|
kicad_cli,
|
|
"sch",
|
|
"export",
|
|
"netlist",
|
|
"--format",
|
|
cli_format,
|
|
"--output",
|
|
output_path,
|
|
schematic_path,
|
|
]
|
|
logger.info(f"Running: {' '.join(cmd)}")
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|
|
|
if result.returncode == 0:
|
|
return {"success": True, "outputPath": output_path, "format": fmt}
|
|
else:
|
|
return {
|
|
"success": False,
|
|
"message": f"kicad-cli failed (exit {result.returncode}): {result.stderr.strip()}",
|
|
}
|
|
|
|
except FileNotFoundError:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
except subprocess.TimeoutExpired:
|
|
return {"success": False, "message": "kicad-cli timed out after 60 seconds"}
|
|
except Exception as e:
|
|
logger.error(f"Error exporting netlist: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_generate_netlist(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Generate netlist from schematic and return structured JSON.
|
|
|
|
Uses kicad-cli to export KiCad XML netlist to a temp file, then
|
|
parses it into {components, nets} structure expected by the TS handler.
|
|
"""
|
|
import subprocess
|
|
import tempfile
|
|
import xml.etree.ElementTree as ET
|
|
|
|
logger.info("Generating netlist from schematic via kicad-cli")
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "Schematic path is required"}
|
|
if not os.path.exists(schematic_path):
|
|
return {"success": False, "message": f"Schematic not found: {schematic_path}"}
|
|
|
|
kicad_cli = self._find_kicad_cli_static()
|
|
if not kicad_cli:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
|
|
with tempfile.NamedTemporaryFile(suffix=".xml", delete=False) as tmp:
|
|
tmp_path = tmp.name
|
|
|
|
try:
|
|
cmd = [
|
|
kicad_cli,
|
|
"sch",
|
|
"export",
|
|
"netlist",
|
|
"--format",
|
|
"kicadxml",
|
|
"--output",
|
|
tmp_path,
|
|
schematic_path,
|
|
]
|
|
logger.info(f"Running: {' '.join(cmd)}")
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|
|
|
if result.returncode != 0:
|
|
return {
|
|
"success": False,
|
|
"message": f"kicad-cli failed (exit {result.returncode}): {result.stderr.strip()}",
|
|
}
|
|
|
|
tree = ET.parse(tmp_path)
|
|
root = tree.getroot()
|
|
|
|
components = []
|
|
for comp in root.findall("./components/comp"):
|
|
ref = comp.get("ref", "")
|
|
value = comp.findtext("value", "")
|
|
footprint = comp.findtext("footprint", "")
|
|
components.append({"reference": ref, "value": value, "footprint": footprint})
|
|
|
|
nets = []
|
|
for net in root.findall("./nets/net"):
|
|
net_name = net.get("name", "")
|
|
connections = []
|
|
for node in net.findall("node"):
|
|
connections.append(
|
|
{
|
|
"component": node.get("ref", ""),
|
|
"pin": node.get("pin", ""),
|
|
}
|
|
)
|
|
nets.append({"name": net_name, "connections": connections})
|
|
|
|
logger.info(f"Generated netlist: {len(components)} components, {len(nets)} nets")
|
|
return {"success": True, "netlist": {"components": components, "nets": nets}}
|
|
|
|
finally:
|
|
try:
|
|
os.unlink(tmp_path)
|
|
except OSError:
|
|
pass
|
|
|
|
except FileNotFoundError:
|
|
return {"success": False, "message": "kicad-cli not found in PATH"}
|
|
except subprocess.TimeoutExpired:
|
|
return {"success": False, "message": "kicad-cli timed out after 60 seconds"}
|
|
except Exception as e:
|
|
logger.error(f"Error generating netlist: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _build_hierarchical_pad_net_map(self, project_sch_path: str):
|
|
"""Walk all .kicad_sch files in the project and build a {(ref, pin_num): net_name} map.
|
|
|
|
Handles hierarchical schematics by scanning every sub-sheet file. Net names
|
|
from global_label / hierarchical_label / local label / power symbols are all
|
|
collected. Wire connectivity is traced via BFS so labels not placed directly
|
|
on a pin endpoint still reach through wire segments.
|
|
|
|
Returns: (pad_net_map, net_names_set)
|
|
"""
|
|
from collections import defaultdict
|
|
from pathlib import Path
|
|
|
|
from commands.pin_locator import PinLocator
|
|
from skip import Schematic
|
|
|
|
TOLERANCE = 0.5 # mm; schematic grid is 1.27 mm so 0.5 is safe
|
|
|
|
def snap(x, y):
|
|
"""Round to 2 dp to use exact dict lookup instead of O(n²) scan."""
|
|
return (round(float(x), 2), round(float(y), 2))
|
|
|
|
def nearby_net(pt, point_net, tol=TOLERANCE):
|
|
"""Return net name for the nearest occupied grid point, or None."""
|
|
x, y = pt
|
|
# Try exact snap first (fast path)
|
|
key = snap(x, y)
|
|
if key in point_net:
|
|
return point_net[key]
|
|
# Slow fallback for off-grid placements
|
|
for (lx, ly), name in point_net.items():
|
|
if abs(x - lx) < tol and abs(y - ly) < tol:
|
|
return name
|
|
return None
|
|
|
|
project_dir = Path(project_sch_path).parent
|
|
pad_net_map: dict = {}
|
|
all_net_names: set = set()
|
|
pin_locator = PinLocator()
|
|
|
|
sch_files = sorted(project_dir.rglob("*.kicad_sch"))
|
|
logger.info(f"_build_hierarchical_pad_net_map: scanning {len(sch_files)} schematic files")
|
|
|
|
for sch_path in sch_files:
|
|
try:
|
|
sch = Schematic(str(sch_path))
|
|
except Exception as e:
|
|
logger.warning(f"Could not load {sch_path}: {e}")
|
|
continue
|
|
|
|
# ── 1. Collect explicit label positions → net name ──────────────
|
|
point_net: dict = {} # snap(x,y) -> net_name
|
|
|
|
for attr in ("label", "global_label", "hierarchical_label"):
|
|
for lbl in getattr(sch, attr, None) or []:
|
|
try:
|
|
pos = lbl.at.value
|
|
name = lbl.value
|
|
if name:
|
|
k = snap(pos[0], pos[1])
|
|
point_net[k] = name
|
|
all_net_names.add(name)
|
|
except Exception:
|
|
pass
|
|
|
|
# Power symbols (#PWR / #FLG): value property IS the net name; use pin 1 pos
|
|
for sym in getattr(sch, "symbol", None) or []:
|
|
try:
|
|
ref = sym.property.Reference.value
|
|
if not (ref.startswith("#PWR") or ref.startswith("#FLG")):
|
|
continue
|
|
net_name = sym.property.Value.value
|
|
if not net_name:
|
|
continue
|
|
all_pins = pin_locator.get_all_symbol_pins(sch_path, ref)
|
|
for _pin_num, (px, py) in all_pins.items():
|
|
k = snap(px, py)
|
|
point_net[k] = net_name
|
|
all_net_names.add(net_name)
|
|
except Exception:
|
|
pass
|
|
|
|
# ── 2. Build wire adjacency and BFS-propagate net names ──────────
|
|
wire_segments = []
|
|
for wire in getattr(sch, "wire", None) or []:
|
|
try:
|
|
pts = []
|
|
for pt in wire.pts.xy:
|
|
pts.append(snap(pt.value[0], pt.value[1]))
|
|
if len(pts) >= 2:
|
|
wire_segments.append(pts)
|
|
except Exception:
|
|
pass
|
|
|
|
# Adjacency: connect endpoints of different segments that share a grid point
|
|
point_adj: dict = defaultdict(set)
|
|
for seg in wire_segments:
|
|
# Connect consecutive points within the segment
|
|
for i in range(len(seg) - 1):
|
|
point_adj[seg[i]].add(seg[i + 1])
|
|
point_adj[seg[i + 1]].add(seg[i])
|
|
|
|
# All unique wire points
|
|
all_wire_pts = set()
|
|
for seg in wire_segments:
|
|
all_wire_pts.update(seg)
|
|
|
|
# BFS: propagate known net names through wire connections
|
|
queue = [pt for pt in all_wire_pts if pt in point_net]
|
|
visited = set(queue)
|
|
while queue:
|
|
pt = queue.pop()
|
|
net = point_net[pt]
|
|
for neighbor in point_adj[pt]:
|
|
if neighbor not in point_net:
|
|
point_net[neighbor] = net
|
|
all_net_names.add(net)
|
|
if neighbor not in visited:
|
|
visited.add(neighbor)
|
|
queue.append(neighbor)
|
|
|
|
# ── 3. Match component pin positions to net names ────────────────
|
|
for sym in getattr(sch, "symbol", None) or []:
|
|
try:
|
|
ref = sym.property.Reference.value
|
|
if ref.startswith("#"):
|
|
continue
|
|
except Exception:
|
|
continue
|
|
|
|
pin_positions = pin_locator.get_all_symbol_pins(sch_path, ref)
|
|
for pin_num, (px, py) in pin_positions.items():
|
|
net = nearby_net((px, py), point_net)
|
|
if net:
|
|
pad_net_map[(ref, pin_num)] = net
|
|
|
|
logger.info(
|
|
f"_build_hierarchical_pad_net_map: {len(pad_net_map)} pin→net assignments, "
|
|
f"{len(all_net_names)} unique nets"
|
|
)
|
|
return pad_net_map, all_net_names
|
|
|
|
def _handle_sync_schematic_to_board(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Sync schematic netlist to PCB board (equivalent to KiCAD F8 'Update PCB from Schematic').
|
|
Reads net connections from the schematic and assigns them to the matching pads in the PCB.
|
|
"""
|
|
logger.info("Syncing schematic to board")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
board_path = params.get("boardPath")
|
|
|
|
# Determine board to work with
|
|
board = None
|
|
if board_path:
|
|
board = pcbnew.LoadBoard(board_path)
|
|
elif self.board:
|
|
board = self.board
|
|
board_path = board.GetFileName() if not board_path else board_path
|
|
else:
|
|
return {
|
|
"success": False,
|
|
"message": "No board loaded. Use open_project first or provide boardPath.",
|
|
}
|
|
|
|
if not board_path:
|
|
board_path = board.GetFileName()
|
|
|
|
# Determine schematic path if not provided
|
|
if not schematic_path:
|
|
sch = Path(board_path).with_suffix(".kicad_sch")
|
|
if sch.exists():
|
|
schematic_path = str(sch)
|
|
else:
|
|
project_dir = Path(board_path).parent
|
|
sch_files = list(project_dir.glob("*.kicad_sch"))
|
|
if sch_files:
|
|
schematic_path = str(sch_files[0])
|
|
|
|
if not schematic_path or not Path(schematic_path).exists():
|
|
return {
|
|
"success": False,
|
|
"message": f"Schematic not found. Provide schematicPath. Tried: {schematic_path}",
|
|
}
|
|
|
|
# Build hierarchical pad→net map (walks all sub-sheets)
|
|
pad_net_map, net_names = self._build_hierarchical_pad_net_map(schematic_path)
|
|
|
|
# Add missing footprints from the schematic to the board *before*
|
|
# we add nets and assign pads — F8 in KiCad does this implicitly
|
|
# ("Update PCB from Schematic"), but our previous implementation
|
|
# only mutated nets, leaving newly-added schematic symbols with no
|
|
# PCB footprint at all.
|
|
added_footprints, skipped_footprints = self._add_missing_footprints_from_schematic(
|
|
board, schematic_path
|
|
)
|
|
|
|
# Add all nets to board
|
|
netinfo = board.GetNetInfo()
|
|
nets_by_name = netinfo.NetsByName()
|
|
added_nets = []
|
|
for net_name in net_names:
|
|
if not nets_by_name.has_key(net_name):
|
|
net_item = pcbnew.NETINFO_ITEM(board, net_name)
|
|
board.Add(net_item)
|
|
added_nets.append(net_name)
|
|
|
|
# Refresh nets map after additions
|
|
netinfo = board.GetNetInfo()
|
|
nets_by_name = netinfo.NetsByName()
|
|
|
|
# Assign nets to pads (now also covers any footprints we just added)
|
|
assigned_pads = 0
|
|
unmatched = []
|
|
for fp in board.GetFootprints():
|
|
ref = fp.GetReference()
|
|
for pad in fp.Pads():
|
|
pad_num = pad.GetNumber()
|
|
key = (ref, str(pad_num))
|
|
if key in pad_net_map:
|
|
net_name = pad_net_map[key]
|
|
if nets_by_name.has_key(net_name):
|
|
pad.SetNet(nets_by_name[net_name])
|
|
assigned_pads += 1
|
|
else:
|
|
unmatched.append(f"{ref}/{pad_num}")
|
|
|
|
board.Save(board_path)
|
|
|
|
# If board was loaded fresh, update internal reference
|
|
if params.get("boardPath"):
|
|
self.board = board
|
|
self._update_command_handlers()
|
|
|
|
logger.info(
|
|
f"sync_schematic_to_board: {len(added_nets)} nets added, "
|
|
f"{len(added_footprints)} footprints added, {assigned_pads} pads assigned"
|
|
)
|
|
return {
|
|
"success": True,
|
|
"message": (
|
|
f"PCB updated from schematic: {len(added_footprints)} footprints added, "
|
|
f"{len(added_nets)} nets added, {assigned_pads} pads assigned"
|
|
),
|
|
"nets_added": added_nets,
|
|
"nets_total": len(net_names),
|
|
"pads_assigned": assigned_pads,
|
|
"unmatched_pads_sample": unmatched[:10],
|
|
"footprints_added": added_footprints,
|
|
"footprints_skipped": skipped_footprints,
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in sync_schematic_to_board: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _extract_components_from_schematic(self, schematic_path: str) -> List[Dict[str, str]]:
|
|
"""Run kicad-cli netlist export and return the flat list of components.
|
|
|
|
Each entry: {"reference": str, "value": str, "footprint": str}
|
|
Empty list on any failure (kicad-cli missing, parse error, etc.) — the
|
|
caller treats that as "no missing footprints to add".
|
|
"""
|
|
import subprocess
|
|
import tempfile
|
|
import xml.etree.ElementTree as ET
|
|
|
|
kicad_cli = self._find_kicad_cli_static()
|
|
if not kicad_cli:
|
|
logger.warning("kicad-cli not found — sync will not add new footprints")
|
|
return []
|
|
|
|
with tempfile.NamedTemporaryFile(suffix=".xml", delete=False) as tmp:
|
|
tmp_path = tmp.name
|
|
try:
|
|
cmd = [
|
|
kicad_cli,
|
|
"sch",
|
|
"export",
|
|
"netlist",
|
|
"--format",
|
|
"kicadxml",
|
|
"--output",
|
|
tmp_path,
|
|
schematic_path,
|
|
]
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|
if result.returncode != 0:
|
|
logger.warning(
|
|
f"kicad-cli netlist export failed (exit {result.returncode}): "
|
|
f"{result.stderr.strip()}"
|
|
)
|
|
return []
|
|
|
|
tree = ET.parse(tmp_path)
|
|
root = tree.getroot()
|
|
components = []
|
|
for comp in root.findall("./components/comp"):
|
|
components.append(
|
|
{
|
|
"reference": comp.get("ref", ""),
|
|
"value": comp.findtext("value", ""),
|
|
"footprint": comp.findtext("footprint", ""),
|
|
}
|
|
)
|
|
return components
|
|
except Exception as e:
|
|
logger.warning(f"Failed to extract components from schematic: {e}")
|
|
return []
|
|
finally:
|
|
try:
|
|
os.unlink(tmp_path)
|
|
except OSError:
|
|
pass
|
|
|
|
def _add_missing_footprints_from_schematic(
|
|
self, board: Any, schematic_path: str
|
|
) -> Tuple[List[Dict[str, str]], List[Dict[str, str]]]:
|
|
"""Add footprints to ``board`` for any schematic component not yet present.
|
|
|
|
New footprints are placed at the board origin so the user can move them
|
|
into position. Power/flag references (``#PWR``, ``#FLG``) are skipped —
|
|
they have no PCB representation.
|
|
|
|
Returns ``(added, skipped)``: each entry is
|
|
``{"reference": str, "footprint": str, "reason": str?}``.
|
|
"""
|
|
from pathlib import Path
|
|
|
|
from commands.library import LibraryManager
|
|
|
|
added: List[Dict[str, str]] = []
|
|
skipped: List[Dict[str, str]] = []
|
|
|
|
components = self._extract_components_from_schematic(schematic_path)
|
|
if not components:
|
|
return added, skipped
|
|
|
|
existing_refs = {fp.GetReference() for fp in board.GetFootprints()}
|
|
project_dir = Path(schematic_path).parent
|
|
library_manager = LibraryManager(project_path=project_dir)
|
|
|
|
for comp in components:
|
|
ref = comp["reference"]
|
|
fp_str = comp["footprint"]
|
|
if not ref or ref.startswith("#"):
|
|
# Power flags / global indicators — no PCB footprint expected.
|
|
continue
|
|
if ref in existing_refs:
|
|
continue
|
|
if not fp_str or ":" not in fp_str:
|
|
skipped.append(
|
|
{
|
|
"reference": ref,
|
|
"footprint": fp_str,
|
|
"reason": "no Library:Name footprint set on schematic symbol",
|
|
}
|
|
)
|
|
continue
|
|
|
|
lib_name, fp_name = fp_str.split(":", 1)
|
|
library_path = library_manager.libraries.get(lib_name)
|
|
if not library_path:
|
|
skipped.append(
|
|
{
|
|
"reference": ref,
|
|
"footprint": fp_str,
|
|
"reason": f"library '{lib_name}' not in fp-lib-table",
|
|
}
|
|
)
|
|
continue
|
|
|
|
try:
|
|
module = pcbnew.FootprintLoad(library_path, fp_name)
|
|
except Exception as e:
|
|
skipped.append(
|
|
{"reference": ref, "footprint": fp_str, "reason": f"FootprintLoad failed: {e}"}
|
|
)
|
|
continue
|
|
|
|
if not module:
|
|
skipped.append(
|
|
{
|
|
"reference": ref,
|
|
"footprint": fp_str,
|
|
"reason": f"footprint '{fp_name}' not in '{lib_name}'",
|
|
}
|
|
)
|
|
continue
|
|
|
|
module.SetReference(ref)
|
|
if comp["value"]:
|
|
module.SetValue(comp["value"])
|
|
module.SetFPID(pcbnew.LIB_ID(lib_name, fp_name))
|
|
# Place at board origin; user / autoplacer can position from there.
|
|
module.SetPosition(pcbnew.VECTOR2I(0, 0))
|
|
|
|
board.Add(module)
|
|
existing_refs.add(ref)
|
|
added.append({"reference": ref, "footprint": fp_str})
|
|
|
|
if added:
|
|
logger.info(f"_add_missing_footprints_from_schematic: added {len(added)} footprints")
|
|
return added, skipped
|
|
|
|
# ===================================================================
|
|
# Schematic analysis tools (read-only)
|
|
# ===================================================================
|
|
|
|
def _handle_get_schematic_view_region(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Export a cropped region of the schematic as an image"""
|
|
logger.info("Exporting schematic view region")
|
|
import base64
|
|
import os
|
|
import subprocess
|
|
import tempfile
|
|
|
|
try:
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path or not os.path.exists(schematic_path):
|
|
return {"success": False, "message": "Schematic file not found"}
|
|
|
|
x1 = float(params.get("x1", 0))
|
|
y1 = float(params.get("y1", 0))
|
|
x2 = float(params.get("x2", 297))
|
|
y2 = float(params.get("y2", 210))
|
|
x1, x2 = min(x1, x2), max(x1, x2)
|
|
y1, y2 = min(y1, y2), max(y1, y2)
|
|
out_format = params.get("format", "png")
|
|
width = int(params.get("width", 800))
|
|
height = int(params.get("height", 600))
|
|
|
|
kicad_cli = self.design_rule_commands._find_kicad_cli()
|
|
if not kicad_cli:
|
|
return {"success": False, "message": "kicad-cli not found"}
|
|
|
|
tmp_dir = tempfile.mkdtemp()
|
|
svg_output = None
|
|
|
|
try:
|
|
cmd = [
|
|
kicad_cli,
|
|
"sch",
|
|
"export",
|
|
"svg",
|
|
"--output",
|
|
tmp_dir,
|
|
schematic_path,
|
|
]
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|
|
|
if result.returncode != 0:
|
|
return {
|
|
"success": False,
|
|
"message": f"SVG export failed: {result.stderr}",
|
|
}
|
|
|
|
# kicad-cli names the file after the schematic
|
|
svg_files = [f for f in os.listdir(tmp_dir) if f.endswith(".svg")]
|
|
if not svg_files:
|
|
return {
|
|
"success": False,
|
|
"message": "kicad-cli produced no SVG output",
|
|
}
|
|
svg_output = os.path.join(tmp_dir, svg_files[0])
|
|
|
|
import xml.etree.ElementTree as ET
|
|
|
|
tree = ET.parse(svg_output)
|
|
root = tree.getroot()
|
|
|
|
# KiCad schematic SVGs use mm as viewBox units directly
|
|
vb = root.get("viewBox", "")
|
|
if vb:
|
|
parts = vb.split()
|
|
if len(parts) == 4:
|
|
orig_vb_x = float(parts[0])
|
|
orig_vb_y = float(parts[1])
|
|
|
|
new_x = orig_vb_x + x1
|
|
new_y = orig_vb_y + y1
|
|
new_w = x2 - x1
|
|
new_h = y2 - y1
|
|
|
|
root.set("viewBox", f"{new_x} {new_y} {new_w} {new_h}")
|
|
root.set("width", str(width))
|
|
root.set("height", str(height))
|
|
|
|
# Write modified SVG
|
|
cropped_svg_path = os.path.join(tmp_dir, "cropped.svg")
|
|
tree.write(cropped_svg_path, xml_declaration=True, encoding="utf-8")
|
|
|
|
if out_format == "svg":
|
|
with open(cropped_svg_path, "r", encoding="utf-8") as f:
|
|
svg_data = f.read()
|
|
return {"success": True, "imageData": svg_data, "format": "svg"}
|
|
else:
|
|
try:
|
|
from cairosvg import svg2png
|
|
except ImportError:
|
|
return {
|
|
"success": False,
|
|
"message": "PNG export requires the 'cairosvg' package. Install it with: pip install cairosvg",
|
|
}
|
|
png_data = svg2png(
|
|
url=cropped_svg_path, output_width=width, output_height=height
|
|
)
|
|
return {
|
|
"success": True,
|
|
"imageData": base64.b64encode(png_data).decode("utf-8"),
|
|
"format": "png",
|
|
}
|
|
finally:
|
|
import shutil
|
|
|
|
shutil.rmtree(tmp_dir, ignore_errors=True)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in get_schematic_view_region: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_find_overlapping_elements(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Detect spatially overlapping symbols, wires, and labels"""
|
|
logger.info("Finding overlapping elements in schematic")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.schematic_analysis import find_overlapping_elements
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
tolerance = float(params.get("tolerance", 0.5))
|
|
result = find_overlapping_elements(Path(schematic_path), tolerance)
|
|
return {
|
|
"success": True,
|
|
**result,
|
|
"message": f"Found {result['totalOverlaps']} overlap(s)",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error finding overlapping elements: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_get_elements_in_region(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List all wires, labels, and symbols within a rectangular region"""
|
|
logger.info("Getting elements in schematic region")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.schematic_analysis import get_elements_in_region
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
x1 = float(params.get("x1", 0))
|
|
y1 = float(params.get("y1", 0))
|
|
x2 = float(params.get("x2", 0))
|
|
y2 = float(params.get("y2", 0))
|
|
|
|
result = get_elements_in_region(Path(schematic_path), x1, y1, x2, y2)
|
|
return {
|
|
"success": True,
|
|
**result,
|
|
"message": f"Found {result['counts']['symbols']} symbols, {result['counts']['wires']} wires, {result['counts']['labels']} labels in region",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error getting elements in region: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_find_wires_crossing_symbols(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Find wires that cross over component symbol bodies"""
|
|
logger.info("Finding wires crossing symbols in schematic")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.schematic_analysis import find_wires_crossing_symbols
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
result = find_wires_crossing_symbols(Path(schematic_path))
|
|
return {
|
|
"success": True,
|
|
"collisions": result,
|
|
"count": len(result),
|
|
"message": f"Found {len(result)} wire(s) crossing symbols",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error checking wire collisions: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_find_orphaned_wires(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Find wire segments with at least one dangling (unconnected) endpoint"""
|
|
logger.info("Finding orphaned wires in schematic")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.schematic_analysis import find_orphaned_wires
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
result = find_orphaned_wires(Path(schematic_path))
|
|
return {
|
|
"success": True,
|
|
**result,
|
|
"message": f"Found {result['count']} orphaned wire(s)",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error finding orphaned wires: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_list_floating_labels(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List net labels that are not connected to any component pin"""
|
|
logger.info("Listing floating net labels in schematic")
|
|
try:
|
|
from commands.wire_connectivity import list_floating_labels
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
schematic = SchematicManager.load_schematic(schematic_path)
|
|
if not schematic:
|
|
return {"success": False, "message": "Failed to load schematic"}
|
|
|
|
labels = list_floating_labels(schematic, schematic_path)
|
|
return {
|
|
"success": True,
|
|
"floating_labels": labels,
|
|
"count": len(labels),
|
|
"message": f"Found {len(labels)} floating label(s)",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error listing floating labels: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_snap_to_grid(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Snap schematic element coordinates to the nearest grid point"""
|
|
logger.info("Snapping schematic elements to grid")
|
|
try:
|
|
from pathlib import Path
|
|
|
|
from commands.schematic_snap import snap_to_grid
|
|
|
|
schematic_path = params.get("schematicPath")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "schematicPath is required"}
|
|
|
|
grid_size = float(params.get("gridSize", 1.27))
|
|
elements = params.get("elements") # None → defaults inside snap_to_grid
|
|
|
|
result = snap_to_grid(Path(schematic_path), grid_size=grid_size, elements=elements)
|
|
total = result["snapped"] + result["already_on_grid"]
|
|
return {
|
|
"success": True,
|
|
**result,
|
|
"message": (
|
|
f"Snapped {result['snapped']} element(s) to {grid_size} mm grid "
|
|
f"({result['already_on_grid']} of {total} were already on grid)"
|
|
),
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error snapping to grid: {e}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_import_svg_logo(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Import an SVG file as PCB graphic polygons on the silkscreen"""
|
|
logger.info("Importing SVG logo into PCB")
|
|
try:
|
|
from commands.svg_import import import_svg_to_pcb
|
|
|
|
pcb_path = params.get("pcbPath")
|
|
svg_path = params.get("svgPath")
|
|
x = float(params.get("x", 0))
|
|
y = float(params.get("y", 0))
|
|
width = float(params.get("width", 10))
|
|
layer = params.get("layer", "F.SilkS")
|
|
stroke_width = float(params.get("strokeWidth", 0))
|
|
filled = bool(params.get("filled", True))
|
|
|
|
if not pcb_path or not svg_path:
|
|
return {
|
|
"success": False,
|
|
"message": "Missing required parameters: pcbPath, svgPath",
|
|
}
|
|
|
|
result = import_svg_to_pcb(pcb_path, svg_path, x, y, width, layer, stroke_width, filled)
|
|
|
|
# import_svg_to_pcb writes gr_poly entries directly to the .kicad_pcb file,
|
|
# bypassing the pcbnew in-memory board object. Any subsequent board.Save()
|
|
# call would overwrite the file with the stale in-memory state, erasing the
|
|
# logo. Reload the board from disk so pcbnew's memory matches the file.
|
|
if result.get("success") and self.board:
|
|
try:
|
|
self.board = pcbnew.LoadBoard(pcb_path)
|
|
# Propagate updated board reference to all command handlers
|
|
self._update_command_handlers()
|
|
logger.info("Reloaded board into pcbnew after SVG logo import")
|
|
except Exception as reload_err:
|
|
logger.warning(
|
|
f"Board reload after SVG import failed (non-fatal): {reload_err}"
|
|
)
|
|
|
|
return result
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error importing SVG logo: {str(e)}")
|
|
import traceback
|
|
|
|
logger.error(traceback.format_exc())
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_snapshot_project(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Copy the entire project folder to a snapshot directory for checkpoint/resume."""
|
|
import shutil
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
|
|
try:
|
|
step = params.get("step", "")
|
|
label = params.get("label", "")
|
|
prompt_text = params.get("prompt", "")
|
|
# Determine project directory from loaded board or explicit path
|
|
project_dir = None
|
|
if self.board:
|
|
board_file = self.board.GetFileName()
|
|
if board_file:
|
|
project_dir = str(Path(board_file).parent)
|
|
if not project_dir:
|
|
project_dir = params.get("projectPath")
|
|
if not project_dir or not os.path.isdir(project_dir):
|
|
return {
|
|
"success": False,
|
|
"message": "Could not determine project directory for snapshot",
|
|
}
|
|
|
|
ts = datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
|
# Save prompt + log into logs/ subdirectory before snapshotting
|
|
logs_dir = Path(project_dir) / "logs"
|
|
logs_dir.mkdir(exist_ok=True)
|
|
|
|
prompt_file = None
|
|
if prompt_text:
|
|
prompt_filename = f"PROMPT_step{step}_{ts}.md" if step else f"PROMPT_{ts}.md"
|
|
prompt_file = logs_dir / prompt_filename
|
|
prompt_file.write_text(prompt_text, encoding="utf-8")
|
|
logger.info(f"Prompt saved: {prompt_file}")
|
|
|
|
# Copy current MCP session log into logs/ before snapshotting
|
|
import platform
|
|
|
|
system = platform.system()
|
|
if system == "Windows":
|
|
mcp_log_dir = os.path.join(os.environ.get("APPDATA", ""), "Claude", "logs")
|
|
elif system == "Darwin":
|
|
mcp_log_dir = os.path.expanduser("~/Library/Logs/Claude")
|
|
else:
|
|
mcp_log_dir = os.path.expanduser("~/.config/Claude/logs")
|
|
mcp_log_src = os.path.join(mcp_log_dir, "mcp-server-kicad.log")
|
|
mcp_log_dest = None
|
|
if os.path.exists(mcp_log_src):
|
|
with open(mcp_log_src, "r", encoding="utf-8", errors="replace") as f:
|
|
all_lines = f.readlines()
|
|
session_start = 0
|
|
for i, line in enumerate(all_lines):
|
|
if "Initializing server" in line:
|
|
session_start = i
|
|
session_lines = all_lines[session_start:]
|
|
log_filename = f"mcp_log_step{step}_{ts}.txt" if step else f"mcp_log_{ts}.txt"
|
|
mcp_log_dest = logs_dir / log_filename
|
|
with open(mcp_log_dest, "w", encoding="utf-8") as f:
|
|
f.writelines(session_lines)
|
|
logger.info(f"MCP session log saved: {mcp_log_dest} ({len(session_lines)} lines)")
|
|
|
|
base_name = Path(project_dir).name
|
|
suffix_parts = [p for p in [f"step{step}" if step else "", label, ts] if p]
|
|
snapshot_name = base_name + "_snapshot_" + "_".join(suffix_parts)
|
|
snapshots_base = Path(project_dir) / "snapshots"
|
|
snapshots_base.mkdir(exist_ok=True)
|
|
snapshot_dir = str(snapshots_base / snapshot_name)
|
|
|
|
shutil.copytree(project_dir, snapshot_dir, ignore=shutil.ignore_patterns("snapshots"))
|
|
logger.info(f"Project snapshot saved: {snapshot_dir}")
|
|
return {
|
|
"success": True,
|
|
"message": f"Snapshot saved: {snapshot_name}",
|
|
"snapshotPath": snapshot_dir,
|
|
"sourceDir": project_dir,
|
|
"promptSaved": str(prompt_file) if prompt_file else None,
|
|
"mcpLogSaved": str(mcp_log_dest) if mcp_log_dest else None,
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"snapshot_project error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_check_kicad_ui(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Check if KiCAD UI is running"""
|
|
logger.info("Checking if KiCAD UI is running")
|
|
try:
|
|
manager = KiCADProcessManager()
|
|
is_running = manager.is_running()
|
|
processes = manager.get_process_info() if is_running else []
|
|
|
|
return {
|
|
"success": True,
|
|
"running": is_running,
|
|
"processes": processes,
|
|
"message": "KiCAD is running" if is_running else "KiCAD is not running",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error checking KiCAD UI status: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_launch_kicad_ui(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Launch KiCAD UI"""
|
|
logger.info("Launching KiCAD UI")
|
|
try:
|
|
project_path = params.get("projectPath")
|
|
auto_launch = params.get("autoLaunch", AUTO_LAUNCH_KICAD)
|
|
|
|
# Convert project path to Path object if provided
|
|
from pathlib import Path
|
|
|
|
path_obj = Path(project_path) if project_path else None
|
|
|
|
result = check_and_launch_kicad(path_obj, auto_launch)
|
|
|
|
return {"success": True, **result}
|
|
except Exception as e:
|
|
logger.error(f"Error launching KiCAD UI: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_refill_zones(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Refill all copper pour zones on the board.
|
|
|
|
pcbnew.ZONE_FILLER.Fill() can cause a C++ access violation (0xC0000005)
|
|
that crashes the entire Python process when called from SWIG outside KiCAD UI.
|
|
To avoid killing the main process we run the fill in an isolated subprocess.
|
|
If the subprocess crashes or times out, we return a non-fatal warning so the
|
|
caller can continue — KiCAD Pcbnew will refill zones automatically when the
|
|
board is opened (press B).
|
|
"""
|
|
logger.info("Refilling zones (subprocess isolation)")
|
|
try:
|
|
if not self.board:
|
|
return {
|
|
"success": False,
|
|
"message": "No board is loaded",
|
|
"errorDetails": "Load or create a board first",
|
|
}
|
|
|
|
# First save the board so the subprocess can load it fresh
|
|
board_path = self.board.GetFileName()
|
|
if not board_path:
|
|
return {
|
|
"success": False,
|
|
"message": "Board has no file path — save first",
|
|
}
|
|
self.board.Save(board_path)
|
|
|
|
zone_count = self.board.GetAreaCount() if hasattr(self.board, "GetAreaCount") else 0
|
|
|
|
# Run pcbnew zone fill in an isolated subprocess to prevent crashes
|
|
import subprocess
|
|
import sys
|
|
import textwrap
|
|
|
|
script = textwrap.dedent(f"""
|
|
import pcbnew, sys
|
|
board = pcbnew.LoadBoard({repr(board_path)})
|
|
filler = pcbnew.ZONE_FILLER(board)
|
|
filler.Fill(board.Zones())
|
|
board.Save({repr(board_path)})
|
|
print("ok")
|
|
""")
|
|
try:
|
|
result = subprocess.run(
|
|
[sys.executable, "-c", script],
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=60,
|
|
)
|
|
if result.returncode == 0 and "ok" in result.stdout:
|
|
# Reload board after subprocess modified it
|
|
self.board = pcbnew.LoadBoard(board_path)
|
|
self._update_command_handlers()
|
|
logger.info("Zone fill subprocess succeeded")
|
|
return {
|
|
"success": True,
|
|
"message": f"Zones refilled successfully ({zone_count} zones)",
|
|
"zoneCount": zone_count,
|
|
}
|
|
else:
|
|
logger.warning(
|
|
f"Zone fill subprocess failed: rc={result.returncode} stderr={result.stderr[:200]}"
|
|
)
|
|
return {
|
|
"success": False,
|
|
"message": "Zone fill failed in subprocess — zones are defined and will fill when opened in KiCAD (press B). Continuing is safe.",
|
|
"zoneCount": zone_count,
|
|
"details": (result.stderr[:300] if result.stderr else result.stdout[:300]),
|
|
}
|
|
except subprocess.TimeoutExpired:
|
|
logger.warning("Zone fill subprocess timed out after 60s")
|
|
return {
|
|
"success": False,
|
|
"message": "Zone fill timed out — zones are defined and will fill when opened in KiCAD (press B). Continuing is safe.",
|
|
"zoneCount": zone_count,
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error refilling zones: {str(e)}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
# =========================================================================
|
|
# IPC Backend handlers - these provide real-time UI synchronization
|
|
# These methods are called automatically when IPC is available
|
|
# =========================================================================
|
|
|
|
def _ipc_route_trace(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for route_trace - adds track with real-time UI update"""
|
|
try:
|
|
# Extract parameters matching the existing route_trace interface
|
|
start = params.get("start", {})
|
|
end = params.get("end", {})
|
|
layer = params.get("layer", "F.Cu")
|
|
width = params.get("width", 0.25)
|
|
net = params.get("net")
|
|
|
|
# Handle both dict format and direct x/y
|
|
start_x = start.get("x", 0) if isinstance(start, dict) else params.get("startX", 0)
|
|
start_y = start.get("y", 0) if isinstance(start, dict) else params.get("startY", 0)
|
|
end_x = end.get("x", 0) if isinstance(end, dict) else params.get("endX", 0)
|
|
end_y = end.get("y", 0) if isinstance(end, dict) else params.get("endY", 0)
|
|
|
|
success = self.ipc_board_api.add_track(
|
|
start_x=start_x,
|
|
start_y=start_y,
|
|
end_x=end_x,
|
|
end_y=end_y,
|
|
width=width,
|
|
layer=layer,
|
|
net_name=net,
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
"Added trace (visible in KiCAD UI)" if success else "Failed to add trace"
|
|
),
|
|
"trace": {
|
|
"start": {"x": start_x, "y": start_y, "unit": "mm"},
|
|
"end": {"x": end_x, "y": end_y, "unit": "mm"},
|
|
"layer": layer,
|
|
"width": width,
|
|
"net": net,
|
|
},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC route_trace error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_route_arc_trace(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for route_arc_trace - adds copper arc with real-time UI update"""
|
|
try:
|
|
start = params.get("start", {})
|
|
mid = params.get("mid", {})
|
|
end = params.get("end", {})
|
|
layer = params.get("layer", "F.Cu")
|
|
width = params.get("width", 0.25)
|
|
net = params.get("net")
|
|
|
|
start_x = start.get("x", 0)
|
|
start_y = start.get("y", 0)
|
|
mid_x = mid.get("x", 0)
|
|
mid_y = mid.get("y", 0)
|
|
end_x = end.get("x", 0)
|
|
end_y = end.get("y", 0)
|
|
|
|
if not hasattr(self.ipc_board_api, "add_arc_track"):
|
|
return {
|
|
"success": False,
|
|
"message": "IPC backend does not support arc track on this installation",
|
|
}
|
|
|
|
success = self.ipc_board_api.add_arc_track(
|
|
start_x=start_x,
|
|
start_y=start_y,
|
|
mid_x=mid_x,
|
|
mid_y=mid_y,
|
|
end_x=end_x,
|
|
end_y=end_y,
|
|
width=width,
|
|
layer=layer,
|
|
net_name=net,
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
"Added arc trace (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to add arc trace"
|
|
),
|
|
"arc": {
|
|
"start": {"x": start_x, "y": start_y, "unit": "mm"},
|
|
"mid": {"x": mid_x, "y": mid_y, "unit": "mm"},
|
|
"end": {"x": end_x, "y": end_y, "unit": "mm"},
|
|
"layer": layer,
|
|
"width": width,
|
|
"net": net,
|
|
},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC route_arc_trace error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_add_via(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for add_via - adds via with real-time UI update"""
|
|
try:
|
|
position = params.get("position", {})
|
|
x = position.get("x", 0) if isinstance(position, dict) else params.get("x", 0)
|
|
y = position.get("y", 0) if isinstance(position, dict) else params.get("y", 0)
|
|
|
|
size = params.get("size", 0.8)
|
|
drill = params.get("drill", 0.4)
|
|
net = params.get("net")
|
|
from_layer = params.get("from_layer", "F.Cu")
|
|
to_layer = params.get("to_layer", "B.Cu")
|
|
|
|
success = self.ipc_board_api.add_via(
|
|
x=x, y=y, diameter=size, drill=drill, net_name=net, via_type="through"
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": ("Added via (visible in KiCAD UI)" if success else "Failed to add via"),
|
|
"via": {
|
|
"position": {"x": x, "y": y, "unit": "mm"},
|
|
"size": size,
|
|
"drill": drill,
|
|
"from_layer": from_layer,
|
|
"to_layer": to_layer,
|
|
"net": net,
|
|
},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC add_via error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_add_net(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for add_net"""
|
|
# Note: Net creation via IPC is limited - nets are typically created
|
|
# when components are placed. Return success for compatibility.
|
|
name = params.get("name")
|
|
logger.info(f"IPC add_net: {name} (nets auto-created with components)")
|
|
return {
|
|
"success": True,
|
|
"message": f"Net '{name}' will be created when components are connected",
|
|
"net": {"name": name},
|
|
}
|
|
|
|
def _ipc_add_copper_pour(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for add_copper_pour - adds zone with real-time UI update"""
|
|
try:
|
|
layer = params.get("layer", "F.Cu")
|
|
net = params.get("net")
|
|
clearance = params.get("clearance", 0.5)
|
|
min_width = params.get("minWidth", 0.25)
|
|
points = params.get("points", [])
|
|
priority = params.get("priority", 0)
|
|
fill_type = params.get("fillType", "solid")
|
|
name = params.get("name", "")
|
|
|
|
if not points or len(points) < 3:
|
|
return {
|
|
"success": False,
|
|
"message": "At least 3 points are required for copper pour outline",
|
|
}
|
|
|
|
# Convert points format if needed (handle both {x, y} and {x, y, unit})
|
|
formatted_points = []
|
|
for point in points:
|
|
formatted_points.append({"x": point.get("x", 0), "y": point.get("y", 0)})
|
|
|
|
success = self.ipc_board_api.add_zone(
|
|
points=formatted_points,
|
|
layer=layer,
|
|
net_name=net,
|
|
clearance=clearance,
|
|
min_thickness=min_width,
|
|
priority=priority,
|
|
fill_mode=fill_type,
|
|
name=name,
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
"Added copper pour (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to add copper pour"
|
|
),
|
|
"pour": {
|
|
"layer": layer,
|
|
"net": net,
|
|
"clearance": clearance,
|
|
"minWidth": min_width,
|
|
"priority": priority,
|
|
"fillType": fill_type,
|
|
"pointCount": len(points),
|
|
},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC add_copper_pour error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_refill_zones(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for refill_zones - refills all zones with real-time UI update"""
|
|
try:
|
|
success = self.ipc_board_api.refill_zones()
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
"Zones refilled (visible in KiCAD UI)" if success else "Failed to refill zones"
|
|
),
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC refill_zones error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_add_text(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for add_text/add_board_text - adds text with real-time UI update"""
|
|
try:
|
|
text = params.get("text", "")
|
|
position = params.get("position", {})
|
|
x = position.get("x", 0) if isinstance(position, dict) else params.get("x", 0)
|
|
y = position.get("y", 0) if isinstance(position, dict) else params.get("y", 0)
|
|
layer = params.get("layer", "F.SilkS")
|
|
size = params.get("size", 1.0)
|
|
rotation = params.get("rotation", 0)
|
|
|
|
success = self.ipc_board_api.add_text(
|
|
text=text, x=x, y=y, layer=layer, size=size, rotation=rotation
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
f"Added text '{text}' (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to add text"
|
|
),
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC add_text error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_set_board_size(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for set_board_size"""
|
|
try:
|
|
width = params.get("width", 100)
|
|
height = params.get("height", 100)
|
|
unit = params.get("unit", "mm")
|
|
|
|
success = self.ipc_board_api.set_size(width, height, unit)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
f"Board size set to {width}x{height} {unit} (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to set board size"
|
|
),
|
|
"boardSize": {"width": width, "height": height, "unit": unit},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC set_board_size error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_get_board_info(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for get_board_info"""
|
|
try:
|
|
size = self.ipc_board_api.get_size()
|
|
components = self.ipc_board_api.list_components()
|
|
tracks = self.ipc_board_api.get_tracks()
|
|
vias = self.ipc_board_api.get_vias()
|
|
nets = self.ipc_board_api.get_nets()
|
|
|
|
return {
|
|
"success": True,
|
|
"boardInfo": {
|
|
"size": size,
|
|
"componentCount": len(components),
|
|
"trackCount": len(tracks),
|
|
"viaCount": len(vias),
|
|
"netCount": len(nets),
|
|
"backend": "ipc",
|
|
"realtime": True,
|
|
},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC get_board_info error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_place_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for place_component - places component with real-time UI update"""
|
|
try:
|
|
reference = params.get("reference", params.get("componentId", ""))
|
|
footprint = params.get("footprint", "")
|
|
position = params.get("position", {})
|
|
x = position.get("x", 0) if isinstance(position, dict) else params.get("x", 0)
|
|
y = position.get("y", 0) if isinstance(position, dict) else params.get("y", 0)
|
|
unit = position.get("unit", "mm") if isinstance(position, dict) else "mm"
|
|
rotation = params.get("rotation", 0)
|
|
layer = params.get("layer", "F.Cu")
|
|
value = params.get("value", "")
|
|
|
|
# Convert inches to mm since ipc_backend expects mm
|
|
if unit == "inch":
|
|
x = x * 25.4
|
|
y = y * 25.4
|
|
|
|
success = self.ipc_board_api.place_component(
|
|
reference=reference,
|
|
footprint=footprint,
|
|
x=x,
|
|
y=y,
|
|
rotation=rotation,
|
|
layer=layer,
|
|
value=value,
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
f"Placed component {reference} (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to place component"
|
|
),
|
|
"component": {
|
|
"reference": reference,
|
|
"footprint": footprint,
|
|
"position": {"x": x, "y": y, "unit": "mm"},
|
|
"rotation": rotation,
|
|
"layer": layer,
|
|
},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC place_component error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_move_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for move_component - moves component with real-time UI update"""
|
|
try:
|
|
reference = params.get("reference", params.get("componentId", ""))
|
|
position = params.get("position", {})
|
|
x = position.get("x", 0) if isinstance(position, dict) else params.get("x", 0)
|
|
y = position.get("y", 0) if isinstance(position, dict) else params.get("y", 0)
|
|
unit = position.get("unit", "mm") if isinstance(position, dict) else "mm"
|
|
rotation = params.get("rotation")
|
|
|
|
# Convert inches to mm since ipc_backend.move_component expects mm
|
|
if unit == "inch":
|
|
x = x * 25.4
|
|
y = y * 25.4
|
|
|
|
success = self.ipc_board_api.move_component(
|
|
reference=reference, x=x, y=y, rotation=rotation
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
f"Moved component {reference} (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to move component"
|
|
),
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC move_component error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_delete_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for delete_component - deletes component with real-time UI update"""
|
|
try:
|
|
reference = params.get("reference", params.get("componentId", ""))
|
|
|
|
success = self.ipc_board_api.delete_component(reference=reference)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
f"Deleted component {reference} (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to delete component"
|
|
),
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC delete_component error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_get_component_list(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for get_component_list"""
|
|
try:
|
|
components = self.ipc_board_api.list_components()
|
|
|
|
# If IPC didn't provide bounding boxes, enrich from SWIG backend
|
|
if self.board and components and not components[0].get("boundingBox"):
|
|
try:
|
|
swig_result = self.component_commands.get_component_list(params)
|
|
if swig_result.get("success"):
|
|
swig_map = {c["reference"]: c for c in swig_result.get("components", [])}
|
|
for comp in components:
|
|
swig_comp = swig_map.get(comp.get("reference"))
|
|
if swig_comp and swig_comp.get("boundingBox"):
|
|
comp["boundingBox"] = swig_comp["boundingBox"]
|
|
except Exception:
|
|
pass
|
|
|
|
return {"success": True, "components": components, "count": len(components)}
|
|
except Exception as e:
|
|
logger.error(f"IPC get_component_list error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_save_project(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for save_project"""
|
|
try:
|
|
success = self.ipc_board_api.save()
|
|
|
|
return {
|
|
"success": success,
|
|
"message": "Project saved" if success else "Failed to save project",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC save_project error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_delete_trace(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for delete_trace - Note: IPC doesn't support direct trace deletion yet"""
|
|
# IPC API doesn't have a direct delete track method
|
|
# Fall back to SWIG for this operation
|
|
logger.info("delete_trace: Falling back to SWIG (IPC doesn't support trace deletion)")
|
|
return self.routing_commands.delete_trace(params)
|
|
|
|
def _ipc_get_nets_list(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for get_nets_list - gets nets with real-time data"""
|
|
try:
|
|
nets = self.ipc_board_api.get_nets()
|
|
|
|
return {"success": True, "nets": nets, "count": len(nets)}
|
|
except Exception as e:
|
|
logger.error(f"IPC get_nets_list error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_add_board_outline(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for add_board_outline - adds board edge with real-time UI update.
|
|
Rounded rectangles are delegated to the SWIG path because the IPC BoardSegment
|
|
type cannot represent arcs; the SWIG path writes directly to the .kicad_pcb file
|
|
and correctly generates PCB_SHAPE arcs for rounded corners.
|
|
"""
|
|
shape = params.get("shape", "rectangle")
|
|
if shape in ("rounded_rectangle", "rectangle"):
|
|
# IPC path only supports straight segments from a points list,
|
|
# but Claude sends rectangle/rounded_rectangle as shape+width+height.
|
|
# Fall back to the SWIG path which correctly handles both shapes.
|
|
logger.info(f"_ipc_add_board_outline: delegating {shape} to SWIG path")
|
|
return self.board_commands.add_board_outline(params)
|
|
|
|
try:
|
|
from kipy.board_types import BoardSegment
|
|
from kipy.geometry import Vector2
|
|
from kipy.proto.board.board_types_pb2 import BoardLayer
|
|
from kipy.util.units import from_mm
|
|
|
|
board = self.ipc_board_api._get_board()
|
|
|
|
# Unwrap nested params (Claude sends {"shape":..., "params":{...}})
|
|
inner = params.get("params", params)
|
|
points = inner.get("points", params.get("points", []))
|
|
width = inner.get("width", params.get("width", 0.1))
|
|
|
|
if len(points) < 2:
|
|
return {
|
|
"success": False,
|
|
"message": "At least 2 points required for board outline",
|
|
}
|
|
|
|
commit = board.begin_commit()
|
|
lines_created = 0
|
|
|
|
# Create line segments connecting the points
|
|
for i in range(len(points)):
|
|
start = points[i]
|
|
end = points[(i + 1) % len(points)] # Wrap around to close the outline
|
|
|
|
segment = BoardSegment()
|
|
segment.start = Vector2.from_xy(
|
|
from_mm(start.get("x", 0)), from_mm(start.get("y", 0))
|
|
)
|
|
segment.end = Vector2.from_xy(from_mm(end.get("x", 0)), from_mm(end.get("y", 0)))
|
|
segment.layer = BoardLayer.BL_Edge_Cuts
|
|
segment.attributes.stroke.width = from_mm(width)
|
|
|
|
board.create_items(segment)
|
|
lines_created += 1
|
|
|
|
board.push_commit(commit, "Added board outline")
|
|
|
|
return {
|
|
"success": True,
|
|
"message": f"Added board outline with {lines_created} segments (visible in KiCAD UI)",
|
|
"segments": lines_created,
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC add_board_outline error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_add_mounting_hole(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for add_mounting_hole - adds mounting hole with real-time UI update"""
|
|
try:
|
|
from kipy.board_types import BoardCircle
|
|
from kipy.geometry import Vector2
|
|
from kipy.proto.board.board_types_pb2 import BoardLayer
|
|
from kipy.util.units import from_mm
|
|
|
|
board = self.ipc_board_api._get_board()
|
|
|
|
x = params.get("x", 0)
|
|
y = params.get("y", 0)
|
|
diameter = params.get("diameter", 3.2) # M3 hole default
|
|
|
|
commit = board.begin_commit()
|
|
|
|
# Create circle on Edge.Cuts layer for the hole
|
|
circle = BoardCircle()
|
|
circle.center = Vector2.from_xy(from_mm(x), from_mm(y))
|
|
circle.radius = from_mm(diameter / 2)
|
|
circle.layer = BoardLayer.BL_Edge_Cuts
|
|
circle.attributes.stroke.width = from_mm(0.1)
|
|
|
|
board.create_items(circle)
|
|
board.push_commit(commit, f"Added mounting hole at ({x}, {y})")
|
|
|
|
return {
|
|
"success": True,
|
|
"message": f"Added mounting hole at ({x}, {y}) mm (visible in KiCAD UI)",
|
|
"hole": {"position": {"x": x, "y": y}, "diameter": diameter},
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC add_mounting_hole error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_get_layer_list(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for get_layer_list - gets enabled layers"""
|
|
try:
|
|
layers = self.ipc_board_api.get_enabled_layers()
|
|
|
|
return {"success": True, "layers": layers, "count": len(layers)}
|
|
except Exception as e:
|
|
logger.error(f"IPC get_layer_list error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_rotate_component(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for rotate_component - rotates component with real-time UI update"""
|
|
try:
|
|
reference = params.get("reference", params.get("componentId", ""))
|
|
angle = params.get("angle", params.get("rotation", 90))
|
|
|
|
# Get current component to find its position
|
|
components = self.ipc_board_api.list_components()
|
|
target = None
|
|
for comp in components:
|
|
if comp.get("reference") == reference:
|
|
target = comp
|
|
break
|
|
|
|
if not target:
|
|
return {"success": False, "message": f"Component {reference} not found"}
|
|
|
|
# Use angle as absolute rotation (matches schema description)
|
|
new_rotation = angle % 360
|
|
|
|
# Use move_component with new rotation (position stays the same)
|
|
success = self.ipc_board_api.move_component(
|
|
reference=reference,
|
|
x=target.get("position", {}).get("x", 0),
|
|
y=target.get("position", {}).get("y", 0),
|
|
rotation=new_rotation,
|
|
)
|
|
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
f"Rotated component {reference} by {angle}° (visible in KiCAD UI)"
|
|
if success
|
|
else "Failed to rotate component"
|
|
),
|
|
"newRotation": new_rotation,
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"IPC rotate_component error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _ipc_get_component_properties(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""IPC handler for get_component_properties - gets detailed component info"""
|
|
try:
|
|
reference = params.get("reference", params.get("componentId", ""))
|
|
|
|
components = self.ipc_board_api.list_components()
|
|
target = None
|
|
for comp in components:
|
|
if comp.get("reference") == reference:
|
|
target = comp
|
|
break
|
|
|
|
if not target:
|
|
return {"success": False, "message": f"Component {reference} not found"}
|
|
|
|
# If IPC didn't provide bounding box, try SWIG backend as fallback
|
|
if not target.get("boundingBox") and self.board:
|
|
try:
|
|
swig_result = self.component_commands.get_component_properties(params)
|
|
if swig_result.get("success"):
|
|
swig_comp = swig_result.get("component", {})
|
|
target["boundingBox"] = swig_comp.get("boundingBox")
|
|
target["courtyard"] = swig_comp.get("courtyard")
|
|
except Exception:
|
|
pass
|
|
|
|
return {"success": True, "component": target}
|
|
except Exception as e:
|
|
logger.error(f"IPC get_component_properties error: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
# =========================================================================
|
|
# Legacy IPC command handlers (explicit ipc_* commands)
|
|
|
|
def _handle_warmup(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Force full pcbnew/wxApp initialisation.
|
|
|
|
On macOS the wxApp singleton is created lazily on the first
|
|
pcbnew operation that needs it (not on ``import pcbnew``).
|
|
That first call can take 55-65 s outside the KiCad GUI, which
|
|
exceeds the 30 s default MCP-client tool-call timeout.
|
|
|
|
This handler is called by the TypeScript server during startup
|
|
(with a 120 s timeout) so the cost is paid before any user
|
|
tools are registered with the MCP client.
|
|
"""
|
|
import time
|
|
start = time.monotonic()
|
|
try:
|
|
# pcbnew.BOARD() triggers wxApp creation on macOS.
|
|
# GetBuildVersion() alone is too cheap — it doesn't
|
|
# force the wxWidgets event loop to materialise.
|
|
board = pcbnew.BOARD()
|
|
del board
|
|
ver = pcbnew.GetBuildVersion()
|
|
elapsed = time.monotonic() - start
|
|
logger.info(f"Warm-up complete: pcbnew {ver} ({elapsed:.1f}s)")
|
|
return {"success": True, "version": ver, "elapsed_s": round(elapsed, 1)}
|
|
except Exception as exc:
|
|
elapsed = time.monotonic() - start
|
|
logger.error(f"Warm-up failed after {elapsed:.1f}s: {exc}")
|
|
return {"success": False, "message": str(exc), "elapsed_s": round(elapsed, 1)}
|
|
# =========================================================================
|
|
|
|
def _handle_get_backend_info(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Get information about the current backend"""
|
|
return {
|
|
"success": True,
|
|
"backend": "ipc" if self.use_ipc else "swig",
|
|
"realtime_sync": self.use_ipc,
|
|
"ipc_connected": (self.ipc_backend.is_connected() if self.ipc_backend else False),
|
|
"version": self.ipc_backend.get_version() if self.ipc_backend else "N/A",
|
|
"message": (
|
|
"Using IPC backend with real-time UI sync"
|
|
if self.use_ipc
|
|
else "Using SWIG backend (requires manual reload)"
|
|
),
|
|
}
|
|
|
|
def _handle_ipc_add_track(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a track using IPC backend (real-time)"""
|
|
if not self.use_ipc or not self.ipc_board_api:
|
|
return {"success": False, "message": "IPC backend not available"}
|
|
|
|
try:
|
|
success = self.ipc_board_api.add_track(
|
|
start_x=params.get("startX", 0),
|
|
start_y=params.get("startY", 0),
|
|
end_x=params.get("endX", 0),
|
|
end_y=params.get("endY", 0),
|
|
width=params.get("width", 0.25),
|
|
layer=params.get("layer", "F.Cu"),
|
|
net_name=params.get("net"),
|
|
)
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
"Track added (visible in KiCAD UI)" if success else "Failed to add track"
|
|
),
|
|
"realtime": True,
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error adding track via IPC: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_ipc_add_via(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add a via using IPC backend (real-time)"""
|
|
if not self.use_ipc or not self.ipc_board_api:
|
|
return {"success": False, "message": "IPC backend not available"}
|
|
|
|
try:
|
|
success = self.ipc_board_api.add_via(
|
|
x=params.get("x", 0),
|
|
y=params.get("y", 0),
|
|
diameter=params.get("diameter", 0.8),
|
|
drill=params.get("drill", 0.4),
|
|
net_name=params.get("net"),
|
|
via_type=params.get("type", "through"),
|
|
)
|
|
return {
|
|
"success": success,
|
|
"message": ("Via added (visible in KiCAD UI)" if success else "Failed to add via"),
|
|
"realtime": True,
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error adding via via IPC: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_ipc_add_text(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Add text using IPC backend (real-time)"""
|
|
if not self.use_ipc or not self.ipc_board_api:
|
|
return {"success": False, "message": "IPC backend not available"}
|
|
|
|
try:
|
|
success = self.ipc_board_api.add_text(
|
|
text=params.get("text", ""),
|
|
x=params.get("x", 0),
|
|
y=params.get("y", 0),
|
|
layer=params.get("layer", "F.SilkS"),
|
|
size=params.get("size", 1.0),
|
|
rotation=params.get("rotation", 0),
|
|
)
|
|
return {
|
|
"success": success,
|
|
"message": (
|
|
"Text added (visible in KiCAD UI)" if success else "Failed to add text"
|
|
),
|
|
"realtime": True,
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error adding text via IPC: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_ipc_list_components(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""List components using IPC backend"""
|
|
if not self.use_ipc or not self.ipc_board_api:
|
|
return {"success": False, "message": "IPC backend not available"}
|
|
|
|
try:
|
|
components = self.ipc_board_api.list_components()
|
|
return {"success": True, "components": components, "count": len(components)}
|
|
except Exception as e:
|
|
logger.error(f"Error listing components via IPC: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_ipc_get_tracks(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Get tracks using IPC backend"""
|
|
if not self.use_ipc or not self.ipc_board_api:
|
|
return {"success": False, "message": "IPC backend not available"}
|
|
|
|
try:
|
|
tracks = self.ipc_board_api.get_tracks()
|
|
return {"success": True, "tracks": tracks, "count": len(tracks)}
|
|
except Exception as e:
|
|
logger.error(f"Error getting tracks via IPC: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_ipc_get_vias(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Get vias using IPC backend"""
|
|
if not self.use_ipc or not self.ipc_board_api:
|
|
return {"success": False, "message": "IPC backend not available"}
|
|
|
|
try:
|
|
vias = self.ipc_board_api.get_vias()
|
|
return {"success": True, "vias": vias, "count": len(vias)}
|
|
except Exception as e:
|
|
logger.error(f"Error getting vias via IPC: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
def _handle_ipc_save_board(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Save board using IPC backend"""
|
|
if not self.use_ipc or not self.ipc_board_api:
|
|
return {"success": False, "message": "IPC backend not available"}
|
|
|
|
try:
|
|
success = self.ipc_board_api.save()
|
|
return {
|
|
"success": success,
|
|
"message": "Board saved" if success else "Failed to save board",
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error saving board via IPC: {e}")
|
|
return {"success": False, "message": str(e)}
|
|
|
|
# JLCPCB API handlers
|
|
|
|
def _handle_download_jlcpcb_database(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Download JLCPCB parts database from JLCSearch API"""
|
|
try:
|
|
force = params.get("force", False)
|
|
|
|
# Check if database exists
|
|
import os
|
|
|
|
stats = self.jlcpcb_parts.get_database_stats()
|
|
if stats["total_parts"] > 0 and not force:
|
|
return {
|
|
"success": False,
|
|
"message": "Database already exists. Use force=true to re-download.",
|
|
"stats": stats,
|
|
}
|
|
|
|
logger.info("Downloading JLCPCB parts database from JLCSearch...")
|
|
|
|
# Download parts from JLCSearch public API (no auth required)
|
|
parts = self.jlcsearch_client.download_all_components(
|
|
callback=lambda total, msg: logger.info(f"{msg}")
|
|
)
|
|
|
|
# Import into database
|
|
logger.info(f"Importing {len(parts)} parts into database...")
|
|
self.jlcpcb_parts.import_jlcsearch_parts(
|
|
parts, progress_callback=lambda curr, total, msg: logger.info(msg)
|
|
)
|
|
|
|
# Get final stats
|
|
stats = self.jlcpcb_parts.get_database_stats()
|
|
|
|
# Calculate database size
|
|
db_size_mb = os.path.getsize(self.jlcpcb_parts.db_path) / (1024 * 1024)
|
|
|
|
return {
|
|
"success": True,
|
|
"total_parts": stats["total_parts"],
|
|
"basic_parts": stats["basic_parts"],
|
|
"extended_parts": stats["extended_parts"],
|
|
"db_size_mb": round(db_size_mb, 2),
|
|
"db_path": stats["db_path"],
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error downloading JLCPCB database: {e}", exc_info=True)
|
|
return {
|
|
"success": False,
|
|
"message": f"Failed to download database: {str(e)}",
|
|
}
|
|
|
|
def _handle_search_jlcpcb_parts(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Search JLCPCB parts database"""
|
|
try:
|
|
query = params.get("query")
|
|
category = params.get("category")
|
|
package = params.get("package")
|
|
library_type = params.get("library_type", "All")
|
|
manufacturer = params.get("manufacturer")
|
|
in_stock = params.get("in_stock", True)
|
|
limit = params.get("limit", 20)
|
|
|
|
# Adjust library_type filter
|
|
if library_type == "All":
|
|
library_type = None
|
|
|
|
parts = self.jlcpcb_parts.search_parts(
|
|
query=query,
|
|
category=category,
|
|
package=package,
|
|
library_type=library_type,
|
|
manufacturer=manufacturer,
|
|
in_stock=in_stock,
|
|
limit=limit,
|
|
)
|
|
|
|
# Add price breaks and footprints to each part
|
|
for part in parts:
|
|
if part.get("price_json"):
|
|
try:
|
|
part["price_breaks"] = json.loads(part["price_json"])
|
|
except:
|
|
part["price_breaks"] = []
|
|
|
|
return {"success": True, "parts": parts, "count": len(parts)}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error searching JLCPCB parts: {e}", exc_info=True)
|
|
return {"success": False, "message": f"Search failed: {str(e)}"}
|
|
|
|
def _handle_get_jlcpcb_part(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Get detailed information for a specific JLCPCB part"""
|
|
try:
|
|
lcsc_number = params.get("lcsc_number")
|
|
if not lcsc_number:
|
|
return {"success": False, "message": "Missing lcsc_number parameter"}
|
|
|
|
part = self.jlcpcb_parts.get_part_info(lcsc_number)
|
|
if not part:
|
|
return {"success": False, "message": f"Part not found: {lcsc_number}"}
|
|
|
|
# Get suggested KiCAD footprints
|
|
footprints = self.jlcpcb_parts.map_package_to_footprint(part.get("package", ""))
|
|
|
|
return {"success": True, "part": part, "footprints": footprints}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error getting JLCPCB part: {e}", exc_info=True)
|
|
return {"success": False, "message": f"Failed to get part info: {str(e)}"}
|
|
|
|
def _handle_get_jlcpcb_database_stats(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Get statistics about JLCPCB database"""
|
|
try:
|
|
stats = self.jlcpcb_parts.get_database_stats()
|
|
return {"success": True, "stats": stats}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error getting database stats: {e}", exc_info=True)
|
|
return {"success": False, "message": f"Failed to get stats: {str(e)}"}
|
|
|
|
def _handle_suggest_jlcpcb_alternatives(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Suggest alternative JLCPCB parts"""
|
|
try:
|
|
lcsc_number = params.get("lcsc_number")
|
|
limit = params.get("limit", 5)
|
|
|
|
if not lcsc_number:
|
|
return {"success": False, "message": "Missing lcsc_number parameter"}
|
|
|
|
# Get original part for price comparison
|
|
original_part = self.jlcpcb_parts.get_part_info(lcsc_number)
|
|
reference_price = None
|
|
if original_part and original_part.get("price_breaks"):
|
|
try:
|
|
reference_price = float(original_part["price_breaks"][0].get("price", 0))
|
|
except:
|
|
pass
|
|
|
|
alternatives = self.jlcpcb_parts.suggest_alternatives(lcsc_number, limit)
|
|
|
|
# Add price breaks to alternatives
|
|
for part in alternatives:
|
|
if part.get("price_json"):
|
|
try:
|
|
part["price_breaks"] = json.loads(part["price_json"])
|
|
except:
|
|
part["price_breaks"] = []
|
|
|
|
return {
|
|
"success": True,
|
|
"alternatives": alternatives,
|
|
"reference_price": reference_price,
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error suggesting alternatives: {e}", exc_info=True)
|
|
return {
|
|
"success": False,
|
|
"message": f"Failed to suggest alternatives: {str(e)}",
|
|
}
|
|
|
|
def _handle_enrich_datasheets(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Enrich schematic Datasheet fields from LCSC numbers"""
|
|
try:
|
|
from pathlib import Path
|
|
|
|
schematic_path = params.get("schematic_path")
|
|
if not schematic_path:
|
|
return {"success": False, "message": "Missing schematic_path parameter"}
|
|
dry_run = params.get("dry_run", False)
|
|
manager = DatasheetManager()
|
|
return manager.enrich_schematic(Path(schematic_path), dry_run=dry_run)
|
|
except Exception as e:
|
|
logger.error(f"Error enriching datasheets: {e}", exc_info=True)
|
|
return {
|
|
"success": False,
|
|
"message": f"Failed to enrich datasheets: {str(e)}",
|
|
}
|
|
|
|
def _handle_get_datasheet_url(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Return LCSC datasheet and product URLs for a part number"""
|
|
try:
|
|
lcsc = params.get("lcsc", "")
|
|
if not lcsc:
|
|
return {"success": False, "message": "Missing lcsc parameter"}
|
|
manager = DatasheetManager()
|
|
datasheet_url = manager.get_datasheet_url(lcsc)
|
|
product_url = manager.get_product_url(lcsc)
|
|
if not datasheet_url:
|
|
return {"success": False, "message": f"Invalid LCSC number: {lcsc}"}
|
|
norm = manager._normalize_lcsc(lcsc)
|
|
return {
|
|
"success": True,
|
|
"lcsc": norm,
|
|
"datasheet_url": datasheet_url,
|
|
"product_url": product_url,
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Error getting datasheet URL: {e}", exc_info=True)
|
|
return {
|
|
"success": False,
|
|
"message": f"Failed to get datasheet URL: {str(e)}",
|
|
}
|
|
|
|
|
|
def _write_response(response_fd: Any, response: Any) -> None:
|
|
"""Write a JSON response to the original stdout fd.
|
|
|
|
All response output goes through this function so that stray C-level
|
|
writes from pcbnew (warnings, diagnostics) never corrupt the JSON
|
|
framing seen by the TypeScript host.
|
|
"""
|
|
payload = json.dumps(response) + "\n"
|
|
os.write(response_fd, payload.encode("utf-8"))
|
|
|
|
|
|
def main() -> None:
|
|
"""Main entry point"""
|
|
# --- Redirect stdout so pcbnew C++ noise never reaches the TS host ---
|
|
# Save the real stdout fd for our exclusive JSON response channel.
|
|
_response_fd = os.dup(1)
|
|
# Point fd 1 (C-level stdout) at stderr so that any printf / std::cout
|
|
# output from pcbnew or other C extensions is visible in logs but does
|
|
# NOT corrupt the JSON stream the TypeScript side is parsing.
|
|
os.dup2(2, 1)
|
|
# Also redirect Python-level stdout to stderr for the same reason.
|
|
sys.stdout = sys.stderr
|
|
|
|
logger.info("Starting KiCAD interface...")
|
|
interface = KiCADInterface()
|
|
# Signal to the TypeScript server that the stdin loop is live.
|
|
_write_response(_response_fd, {"type": "ready"})
|
|
|
|
try:
|
|
logger.info("Processing commands from stdin...")
|
|
# Process commands from stdin
|
|
for line in sys.stdin:
|
|
try:
|
|
# Parse command
|
|
logger.debug(f"Received input: {line.strip()}")
|
|
command_data = json.loads(line)
|
|
|
|
# Check if this is JSON-RPC 2.0 format
|
|
if "jsonrpc" in command_data and command_data["jsonrpc"] == "2.0":
|
|
logger.info("Detected JSON-RPC 2.0 format message")
|
|
method = command_data.get("method")
|
|
params = command_data.get("params", {})
|
|
request_id = command_data.get("id")
|
|
|
|
# Handle MCP protocol methods
|
|
if method == "initialize":
|
|
logger.info("Handling MCP initialize")
|
|
response = {
|
|
"jsonrpc": "2.0",
|
|
"id": request_id,
|
|
"result": {
|
|
"protocolVersion": "2025-06-18",
|
|
"capabilities": {
|
|
"tools": {"listChanged": True},
|
|
"resources": {
|
|
"subscribe": False,
|
|
"listChanged": True,
|
|
},
|
|
},
|
|
"serverInfo": {
|
|
"name": "kicad-mcp-server",
|
|
"title": "KiCAD PCB Design Assistant",
|
|
"version": "2.1.0-alpha",
|
|
},
|
|
"instructions": "AI-assisted PCB design with KiCAD. Use tools to create projects, design boards, place components, route traces, and export manufacturing files.",
|
|
},
|
|
}
|
|
elif method == "tools/list":
|
|
logger.info("Handling MCP tools/list")
|
|
# Return list of available tools with proper schemas
|
|
tools = []
|
|
for cmd_name in interface.command_routes.keys():
|
|
if cmd_name in TOOL_SCHEMAS:
|
|
# Enrich the existing schema with IPC annotation data
|
|
# (adds description/blocking hints where the schema lacks them)
|
|
tool_def = _annotation_loader.enrich_schema(
|
|
cmd_name, TOOL_SCHEMAS[cmd_name]
|
|
)
|
|
tools.append(tool_def)
|
|
else:
|
|
# Build a best-effort schema from IPC annotations
|
|
ann_desc = _annotation_loader.description(cmd_name)
|
|
if ann_desc:
|
|
logger.debug(f"Using IPC annotation for tool: {cmd_name}")
|
|
else:
|
|
logger.warning(f"No schema or annotation for tool: {cmd_name}")
|
|
tools.append(
|
|
_annotation_loader.enrich_schema(
|
|
cmd_name,
|
|
{
|
|
"name": cmd_name,
|
|
"description": ann_desc or f"KiCAD command: {cmd_name}",
|
|
"inputSchema": {
|
|
"type": "object",
|
|
"properties": {},
|
|
},
|
|
},
|
|
)
|
|
)
|
|
|
|
logger.info(f"Returning {len(tools)} tools")
|
|
response = {
|
|
"jsonrpc": "2.0",
|
|
"id": request_id,
|
|
"result": {"tools": tools},
|
|
}
|
|
elif method == "tools/call":
|
|
logger.info("Handling MCP tools/call")
|
|
tool_name = params.get("name")
|
|
tool_params = params.get("arguments", {})
|
|
|
|
# Execute the command
|
|
result = interface.handle_command(tool_name, tool_params)
|
|
|
|
response = {
|
|
"jsonrpc": "2.0",
|
|
"id": request_id,
|
|
"result": {"content": [{"type": "text", "text": json.dumps(result)}]},
|
|
}
|
|
elif method == "resources/list":
|
|
logger.info("Handling MCP resources/list")
|
|
# Return list of available resources
|
|
response = {
|
|
"jsonrpc": "2.0",
|
|
"id": request_id,
|
|
"result": {"resources": RESOURCE_DEFINITIONS},
|
|
}
|
|
elif method == "resources/read":
|
|
logger.info("Handling MCP resources/read")
|
|
resource_uri = params.get("uri")
|
|
|
|
if not resource_uri:
|
|
response = {
|
|
"jsonrpc": "2.0",
|
|
"id": request_id,
|
|
"error": {
|
|
"code": -32602,
|
|
"message": "Missing required parameter: uri",
|
|
},
|
|
}
|
|
else:
|
|
# Read the resource
|
|
resource_data = handle_resource_read(resource_uri, interface)
|
|
|
|
response = {
|
|
"jsonrpc": "2.0",
|
|
"id": request_id,
|
|
"result": resource_data,
|
|
}
|
|
else:
|
|
logger.error(f"Unknown JSON-RPC method: {method}")
|
|
response = {
|
|
"jsonrpc": "2.0",
|
|
"id": request_id,
|
|
"error": {
|
|
"code": -32601,
|
|
"message": f"Method not found: {method}",
|
|
},
|
|
}
|
|
else:
|
|
# Handle legacy custom format
|
|
logger.info("Detected custom format message")
|
|
command = command_data.get("command")
|
|
params = command_data.get("params", {})
|
|
|
|
if not command:
|
|
logger.error("Missing command field")
|
|
response = {
|
|
"success": False,
|
|
"message": "Missing command",
|
|
"errorDetails": "The command field is required",
|
|
}
|
|
else:
|
|
# Handle command
|
|
response = interface.handle_command(command, params)
|
|
|
|
# Send response via the clean fd (immune to pcbnew stdout noise)
|
|
logger.debug(f"Sending response: {response}")
|
|
_write_response(_response_fd, response)
|
|
|
|
except json.JSONDecodeError as e:
|
|
logger.error(f"Invalid JSON input: {str(e)}")
|
|
response = {
|
|
"success": False,
|
|
"message": "Invalid JSON input",
|
|
"errorDetails": str(e),
|
|
}
|
|
_write_response(_response_fd, response)
|
|
|
|
except KeyboardInterrupt:
|
|
logger.info("KiCAD interface stopped")
|
|
sys.exit(0)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Unexpected error: {str(e)}\n{traceback.format_exc()}")
|
|
sys.exit(1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|